65 files changed, 149533 insertions, 1 deletions

diff --git a/src/server/CMakeLists.txt b/src/server/CMakeLists.txt
index f4a7246d9b0..0a8d9ff2c19 100644
--- a/src/server/CMakeLists.txt
+++ b/src/server/CMakeLists.txt
@@ -26,6 +26,7 @@ if(WIN32)
 endif(WIN32)
 
 add_subdirectory(database)
+add_subdirectory(proto)
 add_subdirectory(shared)
 add_subdirectory(bnetserver)
 add_subdirectory(game)
diff --git a/src/server/proto/BattlenetRpcErrorCodes.h b/src/server/proto/BattlenetRpcErrorCodes.h
new file mode 100644
index 00000000000..f9092ecfa3c
--- /dev/null
+++ b/src/server/proto/BattlenetRpcErrorCodes.h
@@ -0,0 +1,671 @@
+/*
+ * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef BattlenetRpcErrorCodes_h__
+#define BattlenetRpcErrorCodes_h__
+
+#include "Define.h"
+
+enum BattlenetRpcErrorCode : uint32
+{
+    ERROR_OK                                                                = 0x00000000,
+    ERROR_INTERNAL                                                          = 0x00000001,
+    ERROR_TIMED_OUT                                                         = 0x00000002,
+    ERROR_DENIED                                                            = 0x00000003,
+    ERROR_NOT_EXISTS                                                        = 0x00000004,
+    ERROR_NOT_STARTED                                                       = 0x00000005,
+    ERROR_IN_PROGRESS                                                       = 0x00000006,
+    ERROR_INVALID_ARGS                                                      = 0x00000007,
+    ERROR_INVALID_SUBSCRIBER                                                = 0x00000008,
+    ERROR_WAITING_FOR_DEPENDENCY                                            = 0x00000009,
+    ERROR_NO_AUTH                                                           = 0x0000000A,
+    ERROR_PARENTAL_CONTROL_RESTRICTION                                      = 0x0000000B,
+    ERROR_NO_GAME_ACCOUNT                                                   = 0x0000000C,
+    ERROR_NOT_IMPLEMENTED                                                   = 0x0000000D,
+    ERROR_OBJECT_REMOVED                                                    = 0x0000000E,
+    ERROR_INVALID_ENTITY_ID                                                 = 0x0000000F,
+    ERROR_INVALID_ENTITY_ACCOUNT_ID                                         = 0x00000010,
+    ERROR_INVALID_ENTITY_GAME_ACCOUNT_ID                                    = 0x00000011,
+    ERROR_INVALID_AGENT_ID                                                  = 0x00000013,
+    ERROR_INVALID_TARGET_ID                                                 = 0x00000014,
+    ERROR_MODULE_NOT_LOADED                                                 = 0x00000015,
+    ERROR_MODULE_NO_ENTRY_POINT                                             = 0x00000016,
+    ERROR_MODULE_SIGNATURE_INCORRECT                                        = 0x00000017,
+    ERROR_MODULE_CREATE_FAILED                                              = 0x00000018,
+    ERROR_NO_PROGRAM                                                        = 0x00000019,
+    ERROR_API_NOT_READY                                                     = 0x0000001B,
+    ERROR_BAD_VERSION                                                       = 0x0000001C,
+    ERROR_ATTRIBUTE_TOO_MANY_ATTRIBUTES_SET                                 = 0x0000001D,
+    ERROR_ATTRIBUTE_MAX_SIZE_EXCEEDED                                       = 0x0000001E,
+    ERROR_ATTRIBUTE_QUOTA_EXCEEDED                                          = 0x0000001F,
+    ERROR_SERVER_POOL_SERVER_DISAPPEARED                                    = 0x00000020,
+    ERROR_SERVER_IS_PRIVATE                                                 = 0x00000021,
+    ERROR_DISABLED                                                          = 0x00000022,
+    ERROR_MODULE_NOT_FOUND                                                  = 0x00000024,
+    ERROR_SERVER_BUSY                                                       = 0x00000025,
+    ERROR_NO_BATTLETAG                                                      = 0x00000026,
+    ERROR_INCOMPLETE_PROFANITY_FILTERS                                      = 0x00000027,
+    ERROR_INVALID_REGION                                                    = 0x00000028,
+    ERROR_EXISTS_ALREADY                                                    = 0x00000029,
+    ERROR_INVALID_SERVER_THUMBPRINT                                         = 0x0000002A,
+    ERROR_PHONE_LOCK                                                        = 0x0000002B,
+    ERROR_SQUELCHED                                                         = 0x0000002C,
+    ERROR_TARGET_OFFLINE                                                    = 0x0000002D,
+    ERROR_BAD_SERVER                                                        = 0x0000002E,
+    ERROR_NO_COOKIE                                                         = 0x0000002F,
+    ERROR_EXPIRED_COOKIE                                                    = 0x00000030,
+    ERROR_TOKEN_NOT_FOUND                                                   = 0x00000031,
+    ERROR_GAME_ACCOUNT_NO_TIME                                              = 0x00000032,
+    ERROR_GAME_ACCOUNT_NO_PLAN                                              = 0x00000033,
+    ERROR_GAME_ACCOUNT_BANNED                                               = 0x00000034,
+    ERROR_GAME_ACCOUNT_SUSPENDED                                            = 0x00000035,
+    ERROR_GAME_ACCOUNT_ALREADY_SELECTED                                     = 0x00000036,
+    ERROR_GAME_ACCOUNT_CANCELLED                                            = 0x00000037,
+    ERROR_GAME_ACCOUNT_CREATION_DISABLED                                    = 0x00000038,
+    ERROR_GAME_ACCOUNT_LOCKED                                               = 0x00000039,
+
+    ERROR_SESSION_DUPLICATE                                                 = 0x0000003C,
+    ERROR_SESSION_DISCONNECTED                                              = 0x0000003D,
+    ERROR_SESSION_DATA_CHANGED                                              = 0x0000003E,
+    ERROR_SESSION_UPDATE_FAILED                                             = 0x0000003F,
+    ERROR_SESSION_NOT_FOUND                                                 = 0x00000040,
+
+    ERROR_ADMIN_KICK                                                        = 0x00000046,
+    ERROR_UNPLANNED_MAINTENANCE                                             = 0x00000047,
+    ERROR_PLANNED_MAINTENANCE                                               = 0x00000048,
+    ERROR_SERVICE_FAILURE_ACCOUNT                                           = 0x00000049,
+    ERROR_SERVICE_FAILURE_SESSION                                           = 0x0000004A,
+    ERROR_SERVICE_FAILURE_AUTH                                              = 0x0000004B,
+    ERROR_SERVICE_FAILURE_RISK                                              = 0x0000004C,
+    ERROR_BAD_PROGRAM                                                       = 0x0000004D,
+    ERROR_BAD_LOCALE                                                        = 0x0000004E,
+    ERROR_BAD_PLATFORM                                                      = 0x0000004F,
+    ERROR_LOCALE_RESTRICTED_LA                                              = 0x00000051,
+    ERROR_LOCALE_RESTRICTED_RU                                              = 0x00000052,
+    ERROR_LOCALE_RESTRICTED_KO                                              = 0x00000053,
+    ERROR_LOCALE_RESTRICTED_TW                                              = 0x00000054,
+    ERROR_LOCALE_RESTRICTED                                                 = 0x00000055,
+    ERROR_ACCOUNT_NEEDS_MAINTENANCE                                         = 0x00000056,
+    ERROR_MODULE_API_ERROR                                                  = 0x00000057,
+    ERROR_MODULE_BAD_CACHE_HANDLE                                           = 0x00000058,
+    ERROR_MODULE_ALREADY_LOADED                                             = 0x00000059,
+    ERROR_NETWORK_BLACKLISTED                                               = 0x0000005A,
+    ERROR_EVENT_PROCESSOR_SLOW                                              = 0x0000005B,
+    ERROR_SERVER_SHUTTING_DOWN                                              = 0x0000005C,
+    ERROR_NETWORK_NOT_PRIVILEGED                                            = 0x0000005D,
+    ERROR_TOO_MANY_OUTSTANDING_REQUESTS                                     = 0x0000005E,
+    ERROR_NO_ACCOUNT_REGISTERED                                             = 0x0000005F,
+    ERROR_BATTLENET_ACCOUNT_BANNED                                          = 0x00000060,
+
+    ERROR_OK_DEPRECATED                                                     = 0x00000064,
+    ERROR_SERVER_IN_MODE_ZOMBIE                                             = 0x00000065,
+
+    ERROR_LOGON_MODULE_REQUIRED                                             = 0x000001F4,
+    ERROR_LOGON_MODULE_NOT_CONFIGURED                                       = 0x000001F5,
+    ERROR_LOGON_MODULE_TIMEOUT                                              = 0x000001F6,
+    ERROR_LOGON_AGREEMENT_REQUIRED                                          = 0x000001FE,
+    ERROR_LOGON_AGREEMENT_NOT_CONFIGURED                                    = 0x000001FF,
+
+    ERROR_LOGON_INVALID_SERVER_PROOF                                        = 0x00000208,
+    ERROR_LOGON_WEB_VERIFY_TIMEOUT                                          = 0x00000209,
+    ERROR_LOGON_INVALID_AUTH_TOKEN                                          = 0x0000020A,
+
+    ERROR_CHALLENGE_SMS_TOO_SOON                                            = 0x00000258,
+    ERROR_CHALLENGE_SMS_THROTTLED                                           = 0x00000259,
+    ERROR_CHALLENGE_SMS_TEMP_OUTAGE                                         = 0x0000025A,
+    ERROR_CHALLENGE_NO_CHALLENGE                                            = 0x0000025B,
+    ERROR_CHALLENGE_NOT_PICKED                                              = 0x0000025C,
+    ERROR_CHALLENGE_ALREADY_PICKED                                          = 0x0000025D,
+    ERROR_CHALLENGE_IN_PROGRESS                                             = 0x0000025E,
+
+    ERROR_CONFIG_FORMAT_INVALID                                             = 0x000002BC,
+    ERROR_CONFIG_NOT_FOUND                                                  = 0x000002BD,
+    ERROR_CONFIG_RETRIEVE_FAILED                                            = 0x000002BE,
+
+    ERROR_NETWORK_MODULE_BUSY                                               = 0x000003E8,
+    ERROR_NETWORK_MODULE_CANT_RESOLVE_ADDRESS                               = 0x000003E9,
+    ERROR_NETWORK_MODULE_CONNECTION_REFUSED                                 = 0x000003EA,
+    ERROR_NETWORK_MODULE_INTERRUPTED                                        = 0x000003EB,
+    ERROR_NETWORK_MODULE_CONNECTION_ABORTED                                 = 0x000003EC,
+    ERROR_NETWORK_MODULE_CONNECTION_RESET                                   = 0x000003ED,
+    ERROR_NETWORK_MODULE_BAD_ADDRESS                                        = 0x000003EE,
+    ERROR_NETWORK_MODULE_NOT_READY                                          = 0x000003EF,
+    ERROR_NETWORK_MODULE_ALREADY_CONNECTED                                  = 0x000003F0,
+    ERROR_NETWORK_MODULE_CANT_CREATE_SOCKET                                 = 0x000003F1,
+    ERROR_NETWORK_MODULE_NETWORK_UNREACHABLE                                = 0x000003F2,
+    ERROR_NETWORK_MODULE_SOCKET_PERMISSION_DENIED                           = 0x000003F3,
+    ERROR_NETWORK_MODULE_NOT_INITIALIZED                                    = 0x000003F4,
+    ERROR_NETWORK_MODULE_NO_SSL_CERTIFICATE_FOR_PEER                        = 0x000003F5,
+    ERROR_NETWORK_MODULE_NO_SSL_COMMON_NAME_FOR_CERTIFICATE                 = 0x000003F6,
+    ERROR_NETWORK_MODULE_SSL_COMMON_NAME_DOES_NOT_MATCH_REMOTE_ENDPOINT     = 0x000003F7,
+    ERROR_NETWORK_MODULE_SOCKET_CLOSED                                      = 0x000003F8,
+    ERROR_NETWORK_MODULE_SSL_PEER_IS_NOT_REGISTERED_IN_CERTBUNDLE           = 0x000003F9,
+    ERROR_NETWORK_MODULE_SSL_INITIALIZE_LOW_FIRST                           = 0x000003FA,
+    ERROR_NETWORK_MODULE_SSL_CERT_BUNDLE_READ_ERROR                         = 0x000003FB,
+    ERROR_NETWORK_MODULE_NO_CERT_BUNDLE                                     = 0x000003FC,
+    ERROR_NETWORK_MODULE_FAILED_TO_DOWNLOAD_CERT_BUNDLE                     = 0x000003FD,
+    ERROR_NETWORK_MODULE_NOT_READY_TO_READ                                  = 0x000003FE,
+
+    ERROR_NETWORK_MODULE_OPENSSL_X509_OK                                    = 0x000004B0,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_UNABLE_TO_GET_ISSUER_CERT             = 0x000004B1,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_UNABLE_TO_GET_CRL                     = 0x000004B2,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_UNABLE_TO_DECRYPT_CERT_SIGNATURE      = 0x000004B3,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_UNABLE_TO_DECRYPT_CRL_SIGNATURE       = 0x000004B4,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY    = 0x000004B5,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_CERT_SIGNATURE_FAILURE                = 0x000004B6,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_CRL_SIGNATURE_FAILURE                 = 0x000004B7,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_CERT_NOT_YET_VALID                    = 0x000004B8,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_CERT_HAS_EXPIRED                      = 0x000004B9,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_CRL_NOT_YET_VALID                     = 0x000004BA,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_CRL_HAS_EXPIRED                       = 0x000004BB,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_ERROR_IN_CERT_NOT_BEFORE_FIELD        = 0x000004BC,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_ERROR_IN_CERT_NOT_AFTER_FIELD         = 0x000004BD,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_ERROR_IN_CRL_LAST_UPDATE_FIELD        = 0x000004BE,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_ERROR_IN_CRL_NEXT_UPDATE_FIELD        = 0x000004BF,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_OUT_OF_MEM                            = 0x000004C0,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_DEPTH_ZERO_SELF_SIGNED_CERT           = 0x000004C1,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_SELF_SIGNED_CERT_IN_CHAIN             = 0x000004C2,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_UNABLE_TO_GET_ISSUER_CERT_LOCALLY     = 0x000004C3,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_UNABLE_TO_VERIFY_LEAF_SIGNATURE       = 0x000004C4,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_CERT_CHAIN_TOO_LONG                   = 0x000004C5,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_CERT_REVOKED                          = 0x000004C6,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_INVALID_CA                            = 0x000004C7,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_PATH_LENGTH_EXCEEDED                  = 0x000004C8,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_INVALID_PURPOSE                       = 0x000004C9,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_CERT_UNTRUSTED                        = 0x000004CA,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_CERT_REJECTED                         = 0x000004CB,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_SUBJECT_ISSUER_MISMATCH               = 0x000004CC,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_AKID_SKID_MISMATCH                    = 0x000004CD,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_AKID_ISSUER_SERIAL_MISMATCH           = 0x000004CE,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_KEYUSAGE_NO_CERTSIGN                  = 0x000004CF,
+    ERROR_NETWORK_MODULE_OPENSSL_X509_APPLICATION_VERIFICATION              = 0x000004D0,
+
+    ERROR_NETWORK_MODULE_SCHANNEL_CANNOT_FIND_OS_VERSION                    = 0x00000514,
+    ERROR_NETWORK_MODULE_SCHANNEL_OS_NOT_SUPPORTED                          = 0x00000515,
+    ERROR_NETWORK_MODULE_SCHANNEL_LOADLIBRARY_FAIL                          = 0x00000516,
+    ERROR_NETWORK_MODULE_SCHANNEL_CANNOT_FIND_INTERFACE                     = 0x00000517,
+    ERROR_NETWORK_MODULE_SCHANNEL_INIT_FAIL                                 = 0x00000518,
+    ERROR_NETWORK_MODULE_SCHANNEL_FUNCTION_CALL_FAIL                        = 0x00000519,
+    ERROR_NETWORK_MODULE_SCHANNEL_X509_UNABLE_TO_GET_ISSUER_CERT            = 0x00000546,
+    ERROR_NETWORK_MODULE_SCHANNEL_X509_TIME_INVALID                         = 0x00000547,
+    ERROR_NETWORK_MODULE_SCHANNEL_X509_SIGNATURE_INVALID                    = 0x00000548,
+    ERROR_NETWORK_MODULE_SCHANNEL_X509_UNABLE_TO_VERIFY_LEAF_SIGNATURE      = 0x00000549,
+    ERROR_NETWORK_MODULE_SCHANNEL_X509_SELF_SIGNED_LEAF_CERTIFICATE         = 0x0000054A,
+    ERROR_NETWORK_MODULE_SCHANNEL_X509_UNHANDLED_ERROR                      = 0x0000054B,
+    ERROR_NETWORK_MODULE_SCHANNEL_X509_SELF_SIGNED_CERT_IN_CHAIN            = 0x0000054C,
+
+    ERROR_WEBSOCKET_HANDSHAKE                                               = 0x00000578,
+
+    ERROR_NETWORK_MODULE_DURANGO_UNKNOWN                                    = 0x000005DC,
+    ERROR_NETWORK_MODULE_DURANGO_MALFORMED_HOST_NAME                        = 0x000005DD,
+    ERROR_NETWORK_MODULE_DURANGO_INVALID_CONNECTION_RESPONSE                = 0x000005DE,
+    ERROR_NETWORK_MODULE_DURANGO_INVALID_CA_CERT                            = 0x000005DF,
+
+    ERROR_RPC_WRITE_FAILED                                                  = 0x00000BB8,
+    ERROR_RPC_SERVICE_NOT_BOUND                                             = 0x00000BB9,
+    ERROR_RPC_TOO_MANY_REQUESTS                                             = 0x00000BBA,
+    ERROR_RPC_PEER_UNKNOWN                                                  = 0x00000BBB,
+    ERROR_RPC_PEER_UNAVAILABLE                                              = 0x00000BBC,
+    ERROR_RPC_PEER_DISCONNECTED                                             = 0x00000BBD,
+    ERROR_RPC_REQUEST_TIMED_OUT                                             = 0x00000BBE,
+    ERROR_RPC_CONNECTION_TIMED_OUT                                          = 0x00000BBF,
+    ERROR_RPC_MALFORMED_RESPONSE                                            = 0x00000BC0,
+    ERROR_RPC_ACCESS_DENIED                                                 = 0x00000BC1,
+    ERROR_RPC_INVALID_SERVICE                                               = 0x00000BC2,
+    ERROR_RPC_INVALID_METHOD                                                = 0x00000BC3,
+    ERROR_RPC_INVALID_OBJECT                                                = 0x00000BC4,
+    ERROR_RPC_MALFORMED_REQUEST                                             = 0x00000BC5,
+    ERROR_RPC_QUOTA_EXCEEDED                                                = 0x00000BC6,
+    ERROR_RPC_NOT_IMPLEMENTED                                               = 0x00000BC7,
+    ERROR_RPC_SERVER_ERROR                                                  = 0x00000BC8,
+    ERROR_RPC_SHUTDOWN                                                      = 0x00000BC9,
+    ERROR_RPC_DISCONNECT                                                    = 0x00000BCA,
+    ERROR_RPC_DISCONNECT_IDLE                                               = 0x00000BCB,
+    ERROR_RPC_PROTOCOL_ERROR                                                = 0x00000BCC,
+    ERROR_RPC_NOT_READY                                                     = 0x00000BCD,
+    ERROR_RPC_FORWARD_FAILED                                                = 0x00000BCE,
+    ERROR_RPC_ENCRYPTION_FAILED                                             = 0x00000BCF,
+    ERROR_RPC_INVALID_ADDRESS                                               = 0x00000BD0,
+    ERROR_RPC_METHOD_DISABLED                                               = 0x00000BD1,
+    ERROR_RPC_SHARD_NOT_FOUND                                               = 0x00000BD2,
+    ERROR_RPC_INVALID_CONNECTION_ID                                         = 0x00000BD3,
+    ERROR_RPC_NOT_CONNECTED                                                 = 0x00000BD4,
+    ERROR_RPC_INVALID_CONNECTION_STATE                                      = 0x00000BD5,
+    ERROR_RPC_SERVICE_ALREADY_REGISTERED                                    = 0x00000BD6,
+
+    ERROR_PRESENCE_INVALID_FIELD_ID                                         = 0x00000FA0,
+    ERROR_PRESENCE_NO_VALID_SUBSCRIBERS                                     = 0x00000FA1,
+    ERROR_PRESENCE_ALREADY_SUBSCRIBED                                       = 0x00000FA2,
+    ERROR_PRESENCE_CONSUMER_NOT_FOUND                                       = 0x00000FA3,
+    ERROR_PRESENCE_CONSUMER_IS_NULL                                         = 0x00000FA4,
+    ERROR_PRESENCE_TEMPORARY_OUTAGE                                         = 0x00000FA5,
+    ERROR_PRESENCE_TOO_MANY_SUBSCRIPTIONS                                   = 0x00000FA6,
+    ERROR_PRESENCE_SUBSCRIPTION_CANCELLED                                   = 0x00000FA7,
+    ERROR_PRESENCE_RICH_PRESENCE_PARSE_ERROR                                = 0x00000FA8,
+    ERROR_PRESENCE_RICH_PRESENCE_XML_ERROR                                  = 0x00000FA9,
+    ERROR_PRESENCE_RICH_PRESENCE_LOAD_ERROR                                 = 0x00000FAA,
+
+    ERROR_FRIENDS_TOO_MANY_SENT_INVITATIONS                                 = 0x00001389,
+    ERROR_FRIENDS_TOO_MANY_RECEIVED_INVITATIONS                             = 0x0000138A,
+    ERROR_FRIENDS_FRIENDSHIP_ALREADY_EXISTS                                 = 0x0000138B,
+    ERROR_FRIENDS_FRIENDSHIP_DOES_NOT_EXIST                                 = 0x0000138C,
+    ERROR_FRIENDS_INVITATION_ALREADY_EXISTS                                 = 0x0000138D,
+    ERROR_FRIENDS_INVALID_INVITATION                                        = 0x0000138E,
+    ERROR_FRIENDS_ALREADY_SUBSCRIBED                                        = 0x0000138F,
+    ERROR_FRIENDS_ACCOUNT_BLOCKED                                           = 0x00001391,
+    ERROR_FRIENDS_NOT_SUBSCRIBED                                            = 0x00001392,
+    ERROR_FRIENDS_INVALID_ROLE_ID                                           = 0x00001393,
+    ERROR_FRIENDS_DISABLED_ROLE_ID                                          = 0x00001394,
+    ERROR_FRIENDS_NOTE_MAX_SIZE_EXCEEDED                                    = 0x00001395,
+    ERROR_FRIENDS_UPDATE_FRIEND_STATE_FAILED                                = 0x00001396,
+    ERROR_FRIENDS_INVITEE_AT_MAX_FRIENDS                                    = 0x00001397,
+    ERROR_FRIENDS_INVITER_AT_MAX_FRIENDS                                    = 0x00001398,
+
+    ERROR_PLATFORM_STORAGE_FILE_WRITE_DENIED                                = 0x00001770,
+
+    ERROR_WHISPER_UNDELIVERABLE                                             = 0x00001B58,
+    ERROR_WHISPER_MAX_SIZE_EXCEEDED                                         = 0x00001B59,
+
+    ERROR_USER_MANAGER_ALREADY_BLOCKED                                      = 0x00001F40,
+    ERROR_USER_MANAGER_NOT_BLOCKED                                          = 0x00001F41,
+    ERROR_USER_MANAGER_CANNOT_BLOCK_SELF                                    = 0x00001F42,
+    ERROR_USER_MANAGER_ALREADY_REGISTERED                                   = 0x00001F43,
+    ERROR_USER_MANAGER_NOT_REGISTERED                                       = 0x00001F44,
+    ERROR_USER_MANAGER_TOO_MANY_BLOCKED_ENTITIES                            = 0x00001F45,
+    ERROR_USER_MANAGER_TOO_MANY_IDS                                         = 0x00001F47,
+    ERROR_USER_MANAGER_BLOCK_RECORD_UNAVAILABLE                             = 0x00001F4F,
+    ERROR_USER_MANAGER_BLOCK_ENTITY_FAILED                                  = 0x00001F50,
+    ERROR_USER_MANAGER_UNBLOCK_ENTITY_FAILED                                = 0x00001F51,
+    ERROR_USER_MANAGER_CANNOT_BLOCK_FRIEND                                  = 0x00001F53,
+
+    ERROR_SOCIAL_NETWORK_DB_EXCEPTION                                       = 0x00002328,
+    ERROR_SOCIAL_NETWORK_DENIAL_FROM_PROVIDER                               = 0x00002329,
+    ERROR_SOCIAL_NETWORK_INVALID_SNS_ID                                     = 0x0000232A,
+    ERROR_SOCIAL_NETWORK_CANT_SEND_TO_PROVIDER                              = 0x0000232B,
+    ERROR_SOCIAL_NETWORK_EX_COMM_FAILED                                     = 0x0000232C,
+    ERROR_SOCIAL_NETWORK_DISABLED                                           = 0x0000232D,
+    ERROR_SOCIAL_NETWORK_MISSING_REQUEST_PARAM                              = 0x0000232E,
+    ERROR_SOCIAL_NETWORK_UNSUPPORTED_OAUTH_VERSION                          = 0x0000232F,
+
+    ERROR_CHANNEL_FULL                                                      = 0x00002710,
+    ERROR_CHANNEL_NO_CHANNEL                                                = 0x00002711,
+    ERROR_CHANNEL_NOT_MEMBER                                                = 0x00002712,
+    ERROR_CHANNEL_ALREADY_MEMBER                                            = 0x00002713,
+    ERROR_CHANNEL_NO_SUCH_MEMBER                                            = 0x00002714,
+    ERROR_CHANNEL_INVALID_CHANNEL_ID                                        = 0x00002716,
+    ERROR_CHANNEL_NO_SUCH_INVITATION                                        = 0x00002718,
+    ERROR_CHANNEL_TOO_MANY_INVITATIONS                                      = 0x00002719,
+    ERROR_CHANNEL_INVITATION_ALREADY_EXISTS                                 = 0x0000271A,
+    ERROR_CHANNEL_INVALID_CHANNEL_SIZE                                      = 0x0000271B,
+    ERROR_CHANNEL_INVALID_ROLE_ID                                           = 0x0000271C,
+    ERROR_CHANNEL_ROLE_NOT_ASSIGNABLE                                       = 0x0000271D,
+    ERROR_CHANNEL_INSUFFICIENT_PRIVILEGES                                   = 0x0000271E,
+    ERROR_CHANNEL_INSUFFICIENT_PRIVACY_LEVEL                                = 0x0000271F,
+    ERROR_CHANNEL_INVALID_PRIVACY_LEVEL                                     = 0x00002720,
+    ERROR_CHANNEL_TOO_MANY_CHANNELS_JOINED                                  = 0x00002721,
+    ERROR_CHANNEL_INVITATION_ALREADY_SUBSCRIBED                             = 0x00002722,
+    ERROR_CHANNEL_INVALID_CHANNEL_DELEGATE                                  = 0x00002723,
+    ERROR_CHANNEL_SLOT_ALREADY_RESERVED                                     = 0x00002724,
+    ERROR_CHANNEL_SLOT_NOT_RESERVED                                         = 0x00002725,
+    ERROR_CHANNEL_NO_RESERVED_SLOTS_AVAILABLE                               = 0x00002726,
+    ERROR_CHANNEL_INVALID_ROLE_SET                                          = 0x00002727,
+    ERROR_CHANNEL_REQUIRE_FRIEND_VALIDATION                                 = 0x00002728,
+    ERROR_CHANNEL_MEMBER_OFFLINE                                            = 0x00002729,
+    ERROR_CHANNEL_RECEIVED_TOO_MANY_INVITATIONS                             = 0x0000272A,
+    ERROR_CHANNEL_INVITATION_INVALID_GAME_ACCOUNT_SELECTED                  = 0x0000272B,
+    ERROR_CHANNEL_UNREACHABLE                                               = 0x0000272C,
+    ERROR_CHANNEL_INVITATION_NOT_SUBSCRIBED                                 = 0x0000272D,
+    ERROR_CHANNEL_INVALID_MESSAGE_SIZE                                      = 0x0000272E,
+    ERROR_CHANNEL_MAX_MESSAGE_SIZE_EXCEEDED                                 = 0x0000272F,
+    ERROR_CHANNEL_CONFIG_NOT_FOUND                                          = 0x00002730,
+    ERROR_CHANNEL_INVALID_CHANNEL_TYPE                                      = 0x00002731,
+
+    ERROR_LOCAL_STORAGE_FILE_OPEN_ERROR                                     = 0x00002AF8,
+    ERROR_LOCAL_STORAGE_FILE_CREATE_ERROR                                   = 0x00002AF9,
+    ERROR_LOCAL_STORAGE_FILE_READ_ERROR                                     = 0x00002AFA,
+    ERROR_LOCAL_STORAGE_FILE_WRITE_ERROR                                    = 0x00002AFB,
+    ERROR_LOCAL_STORAGE_FILE_DELETE_ERROR                                   = 0x00002AFC,
+    ERROR_LOCAL_STORAGE_FILE_COPY_ERROR                                     = 0x00002AFD,
+    ERROR_LOCAL_STORAGE_FILE_DECOMPRESS_ERROR                               = 0x00002AFE,
+    ERROR_LOCAL_STORAGE_FILE_HASH_MISMATCH                                  = 0x00002AFF,
+    ERROR_LOCAL_STORAGE_FILE_USAGE_MISMATCH                                 = 0x00002B00,
+    ERROR_LOCAL_STORAGE_DATABASE_INIT_ERROR                                 = 0x00002B01,
+    ERROR_LOCAL_STORAGE_DATABASE_NEEDS_REBUILD                              = 0x00002B02,
+    ERROR_LOCAL_STORAGE_DATABASE_INSERT_ERROR                               = 0x00002B03,
+    ERROR_LOCAL_STORAGE_DATABASE_LOOKUP_ERROR                               = 0x00002B04,
+    ERROR_LOCAL_STORAGE_DATABASE_UPDATE_ERROR                               = 0x00002B05,
+    ERROR_LOCAL_STORAGE_DATABASE_DELETE_ERROR                               = 0x00002B06,
+    ERROR_LOCAL_STORAGE_DATABASE_SHRINK_ERROR                               = 0x00002B07,
+    ERROR_LOCAL_STORAGE_CACHE_CRAWL_ERROR                                   = 0x00002B08,
+    ERROR_LOCAL_STORAGE_DATABASE_INDEX_TRIGGER_ERROR                        = 0x00002B09,
+    ERROR_LOCAL_STORAGE_DATABASE_REBUILD_IN_PROGRESS                        = 0x00002B0A,
+    ERROR_LOCAL_STORAGE_OK_BUT_NOT_IN_CACHE                                 = 0x00002B0B,
+    ERROR_LOCAL_STORAGE_DATABASE_REBUILD_INTERRUPTED                        = 0x00002B0D,
+    ERROR_LOCAL_STORAGE_DATABASE_NOT_INITIALIZED                            = 0x00002B0E,
+    ERROR_LOCAL_STORAGE_DIRECTORY_CREATE_ERROR                              = 0x00002B0F,
+    ERROR_LOCAL_STORAGE_FILEKEY_NOT_FOUND                                   = 0x00002B10,
+    ERROR_LOCAL_STORAGE_NOT_AVAILABLE_ON_SERVER                             = 0x00002B11,
+
+    ERROR_REGISTRY_CREATE_KEY_ERROR                                         = 0x00002EE0,
+    ERROR_REGISTRY_OPEN_KEY_ERROR                                           = 0x00002EE1,
+    ERROR_REGISTRY_READ_ERROR                                               = 0x00002EE2,
+    ERROR_REGISTRY_WRITE_ERROR                                              = 0x00002EE3,
+    ERROR_REGISTRY_TYPE_ERROR                                               = 0x00002EE4,
+    ERROR_REGISTRY_DELETE_ERROR                                             = 0x00002EE5,
+    ERROR_REGISTRY_ENCRYPT_ERROR                                            = 0x00002EE6,
+    ERROR_REGISTRY_DECRYPT_ERROR                                            = 0x00002EE7,
+    ERROR_REGISTRY_KEY_SIZE_ERROR                                           = 0x00002EE8,
+    ERROR_REGISTRY_VALUE_SIZE_ERROR                                         = 0x00002EE9,
+    ERROR_REGISTRY_NOT_FOUND                                                = 0x00002EEB,
+    ERROR_REGISTRY_MALFORMED_STRING                                         = 0x00002EEC,
+
+    ERROR_INTERFACE_ALREADY_CONNECTED                                       = 0x000032C8,
+    ERROR_INTERFACE_NOT_READY                                               = 0x000032C9,
+    ERROR_INTERFACE_OPTION_KEY_TOO_LARGE                                    = 0x000032CA,
+    ERROR_INTERFACE_OPTION_VALUE_TOO_LARGE                                  = 0x000032CB,
+    ERROR_INTERFACE_OPTION_KEY_INVALID_UTF8_STRING                          = 0x000032CC,
+    ERROR_INTERFACE_OPTION_VALUE_INVALID_UTF8_STRING                        = 0x000032CD,
+
+    ERROR_HTTP_COULDNT_RESOLVE                                              = 0x000036B0,
+    ERROR_HTTP_COULDNT_CONNECT                                              = 0x000036B1,
+    ERROR_HTTP_TIMEOUT                                                      = 0x000036B2,
+    ERROR_HTTP_FAILED                                                       = 0x000036B3,
+    ERROR_HTTP_MALFORMED_URL                                                = 0x000036B4,
+    ERROR_HTTP_DOWNLOAD_ABORTED                                             = 0x000036B5,
+    ERROR_HTTP_COULDNT_WRITE_FILE                                           = 0x000036B6,
+    ERROR_HTTP_TOO_MANY_REDIRECTS                                           = 0x000036B7,
+    ERROR_HTTP_COULDNT_OPEN_FILE                                            = 0x000036B8,
+    ERROR_HTTP_COULDNT_CREATE_FILE                                          = 0x000036B9,
+    ERROR_HTTP_COULDNT_READ_FILE                                            = 0x000036BA,
+    ERROR_HTTP_COULDNT_RENAME_FILE                                          = 0x000036BB,
+    ERROR_HTTP_COULDNT_CREATE_DIRECTORY                                     = 0x000036BC,
+    ERROR_HTTP_CURL_IS_NOT_READY                                            = 0x000036BD,
+    ERROR_HTTP_CANCELLED                                                    = 0x000036BE,
+
+    ERROR_HTTP_FILE_NOT_FOUND                                               = 0x00003844,
+
+    ERROR_ACCOUNT_MISSING_CONFIG                                            = 0x00004650,
+    ERROR_ACCOUNT_DATA_NOT_FOUND                                            = 0x00004651,
+    ERROR_ACCOUNT_ALREADY_SUBSCRIBED                                        = 0x00004652,
+    ERROR_ACCOUNT_NOT_SUBSCRIBED                                            = 0x00004653,
+    ERROR_ACCOUNT_FAILED_TO_PARSE_TIMEZONE_DATA                             = 0x00004654,
+    ERROR_ACCOUNT_LOAD_FAILED                                               = 0x00004655,
+    ERROR_ACCOUNT_LOAD_CANCELLED                                            = 0x00004656,
+    ERROR_ACCOUNT_DATABASE_INVALIDATE_FAILED                                = 0x00004657,
+    ERROR_ACCOUNT_CACHE_INVALIDATE_FAILED                                   = 0x00004658,
+    ERROR_ACCOUNT_SUBSCRIPTION_PENDING                                      = 0x00004659,
+    ERROR_ACCOUNT_UNKNOWN_REGION                                            = 0x0000465A,
+    ERROR_ACCOUNT_DATA_FAILED_TO_PARSE                                      = 0x0000465B,
+    ERROR_ACCOUNT_UNDERAGE                                                  = 0x0000465C,
+    ERROR_ACCOUNT_IDENTITY_CHECK_PENDING                                    = 0x0000465D,
+    ERROR_ACCOUNT_IDENTITY_UNVERIFIED                                       = 0x0000465E,
+
+    ERROR_DATABASE_BINDING_COUNT_MISMATCH                                   = 0x00004A38,
+    ERROR_DATABASE_BINDING_PARSE_FAIL                                       = 0x00004A39,
+    ERROR_DATABASE_RESULTSET_COLUMNS_MISMATCH                               = 0x00004A3A,
+    ERROR_DATABASE_DEADLOCK                                                 = 0x00004A3B,
+    ERROR_DATABASE_DUPLICATE_KEY                                            = 0x00004A3C,
+    ERROR_DATABASE_CANNOT_CONNECT                                           = 0x00004A3D,
+    ERROR_DATABASE_STATEMENT_FAILED                                         = 0x00004A3E,
+    ERROR_DATABASE_TRANSACTION_NOT_STARTED                                  = 0x00004A3F,
+    ERROR_DATABASE_TRANSACTION_NOT_ENDED                                    = 0x00004A40,
+    ERROR_DATABASE_TRANSACTION_LEAK                                         = 0x00004A41,
+    ERROR_DATABASE_TRANSACTION_STATE_BAD                                    = 0x00004A42,
+    ERROR_DATABASE_SERVER_GONE                                              = 0x00004A43,
+    ERROR_DATABASE_QUERY_TIMEOUT                                            = 0x00004A44,
+    ERROR_DATABASE_BINDING_NOT_NULLABLE                                     = 0x00004A9C,
+    ERROR_DATABASE_BINDING_INVALID_INTEGER                                  = 0x00004A9D,
+    ERROR_DATABASE_BINDING_INVALID_FLOAT                                    = 0x00004A9E,
+    ERROR_DATABASE_BINDING_INVALID_TEMPORAL                                 = 0x00004A9F,
+    ERROR_DATABASE_BINDING_INVALID_PROTOBUF                                 = 0x00004AA0,
+
+    ERROR_PARTY_INVALID_PARTY_ID                                            = 0x00004E20,
+    ERROR_PARTY_ALREADY_IN_PARTY                                            = 0x00004E21,
+    ERROR_PARTY_NOT_IN_PARTY                                                = 0x00004E22,
+    ERROR_PARTY_INVITATION_UNDELIVERABLE                                    = 0x00004E23,
+    ERROR_PARTY_INVITATION_ALREADY_EXISTS                                   = 0x00004E24,
+    ERROR_PARTY_TOO_MANY_PARTY_INVITATIONS                                  = 0x00004E25,
+    ERROR_PARTY_TOO_MANY_RECEIVED_INVITATIONS                               = 0x00004E26,
+    ERROR_PARTY_NO_SUCH_TYPE                                                = 0x00004E27,
+
+    ERROR_GAMES_NO_SUCH_FACTORY                                             = 0x000055F0,
+    ERROR_GAMES_NO_SUCH_GAME                                                = 0x000055F1,
+    ERROR_GAMES_NO_SUCH_REQUEST                                             = 0x000055F2,
+    ERROR_GAMES_NO_SUCH_PARTY_MEMBER                                        = 0x000055F3,
+
+    ERROR_RESOURCES_OFFLINE                                                 = 0x000059D8,
+
+    ERROR_GAME_SERVER_CREATE_GAME_REFUSED                                   = 0x00005DC0,
+    ERROR_GAME_SERVER_ADD_PLAYERS_REFUSED                                   = 0x00005DC1,
+    ERROR_GAME_SERVER_REMOVE_PLAYERS_REFUSED                                = 0x00005DC2,
+    ERROR_GAME_SERVER_FINISH_GAME_REFUSED                                   = 0x00005DC3,
+    ERROR_GAME_SERVER_NO_SUCH_GAME                                          = 0x00005DC4,
+    ERROR_GAME_SERVER_NO_SUCH_PLAYER                                        = 0x00005DC5,
+    ERROR_GAME_SERVER_CREATE_GAME_REFUSED_TRANSIENT                         = 0x00005DF2,
+    ERROR_GAME_SERVER_ADD_PLAYERS_REFUSED_TRANSIENT                         = 0x00005DF3,
+    ERROR_GAME_SERVER_REMOVE_PLAYERS_REFUSED_TRANSIENT                      = 0x00005DF4,
+    ERROR_GAME_SERVER_FINISH_GAME_REFUSED_TRANSIENT                         = 0x00005DF5,
+    ERROR_GAME_SERVER_CREATE_GAME_REFUSED_BUSY                              = 0x00005E24,
+    ERROR_GAME_SERVER_ADD_PLAYERS_REFUSED_BUSY                              = 0x00005E25,
+    ERROR_GAME_SERVER_REMOVE_PLAYERS_REFUSED_BUSY                           = 0x00005E26,
+    ERROR_GAME_SERVER_FINISH_GAME_REFUSED_BUSY                              = 0x00005E27,
+
+    ERROR_GAME_MASTER_INVALID_FACTORY                                       = 0x000061A8,
+    ERROR_GAME_MASTER_INVALID_GAME                                          = 0x000061A9,
+    ERROR_GAME_MASTER_GAME_FULL                                             = 0x000061AA,
+    ERROR_GAME_MASTER_REGISTER_FAILED                                       = 0x000061AB,
+    ERROR_GAME_MASTER_NO_GAME_SERVER                                        = 0x000061AC,
+    ERROR_GAME_MASTER_NO_UTILITY_SERVER                                     = 0x000061AD,
+    ERROR_GAME_MASTER_NO_GAME_VERSION                                       = 0x000061AE,
+    ERROR_GAME_MASTER_GAME_JOIN_FAILED                                      = 0x000061AF,
+    ERROR_GAME_MASTER_ALREADY_REGISTERED                                    = 0x000061B0,
+    ERROR_GAME_MASTER_NO_FACTORY                                            = 0x000061B1,
+    ERROR_GAME_MASTER_MULTIPLE_GAME_VERSIONS                                = 0x000061B2,
+    ERROR_GAME_MASTER_INVALID_PLAYER                                        = 0x000061B3,
+    ERROR_GAME_MASTER_INVALID_GAME_REQUEST                                  = 0x000061B4,
+    ERROR_GAME_MASTER_INSUFFICIENT_PRIVILEGES                               = 0x000061B5,
+    ERROR_GAME_MASTER_ALREADY_IN_GAME                                       = 0x000061B6,
+    ERROR_GAME_MASTER_INVALID_GAME_SERVER_RESPONSE                          = 0x000061B7,
+    ERROR_GAME_MASTER_GAME_ACCOUNT_LOOKUP_FAILED                            = 0x000061B8,
+    ERROR_GAME_MASTER_GAME_ENTRY_CANCELLED                                  = 0x000061B9,
+    ERROR_GAME_MASTER_GAME_ENTRY_ABORTED_CLIENT_DROPPED                     = 0x000061BA,
+    ERROR_GAME_MASTER_GAME_ENTRY_ABORTED_BY_SERVICE                         = 0x000061BB,
+    ERROR_GAME_MASTER_NO_AVAILABLE_CAPACITY                                 = 0x000061BC,
+    ERROR_GAME_MASTER_INVALID_TEAM_ID                                       = 0x000061BD,
+    ERROR_GAME_MASTER_CREATION_IN_PROGRESS                                  = 0x000061BE,
+
+    ERROR_NOTIFICATION_INVALID_CLIENT_ID                                    = 0x00006590,
+    ERROR_NOTIFICATION_DUPLICATE_NAME                                       = 0x00006591,
+    ERROR_NOTIFICATION_NAME_NOT_FOUND                                       = 0x00006592,
+    ERROR_NOTIFICATION_INVALID_SERVER                                       = 0x00006593,
+    ERROR_NOTIFICATION_QUOTA_EXCEEDED                                       = 0x00006594,
+    ERROR_NOTIFICATION_INVALID_NOTIFICATION_TYPE                            = 0x00006595,
+    ERROR_NOTIFICATION_UNDELIVERABLE                                        = 0x00006596,
+    ERROR_NOTIFICATION_UNDELIVERABLE_TEMPORARY                              = 0x00006597,
+
+    ERROR_ACHIEVEMENTS_NOTHING_TO_UPDATE                                    = 0x00006D60,
+    ERROR_ACHIEVEMENTS_INVALID_PARAMS                                       = 0x00006D61,
+    ERROR_ACHIEVEMENTS_NOT_REGISTERED                                       = 0x00006D62,
+    ERROR_ACHIEVEMENTS_NOT_READY                                            = 0x00006D63,
+    ERROR_ACHIEVEMENTS_FAILED_TO_PARSE_STATIC_DATA                          = 0x00006D64,
+    ERROR_ACHIEVEMENTS_UNKNOWN_ID                                           = 0x00006D65,
+    ERROR_ACHIEVEMENTS_MISSING_SNAPSHOT                                     = 0x00006D66,
+    ERROR_ACHIEVEMENTS_ALREADY_REGISTERED                                   = 0x00006D67,
+    ERROR_ACHIEVEMENTS_TOO_MANY_REGISTRATIONS                               = 0x00006D68,
+    ERROR_ACHIEVEMENTS_ALREADY_IN_PROGRESS                                  = 0x00006D69,
+    ERROR_ACHIEVEMENTS_TEMPORARY_OUTAGE                                     = 0x00006D6A,
+    ERROR_ACHIEVEMENTS_INVALID_PROGRAMID                                    = 0x00006D6B,
+    ERROR_ACHIEVEMENTS_MISSING_RECORD                                       = 0x00006D6C,
+    ERROR_ACHIEVEMENTS_REGISTRATION_PENDING                                 = 0x00006D6D,
+    ERROR_ACHIEVEMENTS_ENTITY_ID_NOT_FOUND                                  = 0x00006D6E,
+    ERROR_ACHIEVEMENTS_ACHIEVEMENT_ID_NOT_FOUND                             = 0x00006D6F,
+    ERROR_ACHIEVEMENTS_CRITERIA_ID_NOT_FOUND                                = 0x00006D70,
+    ERROR_ACHIEVEMENTS_STATIC_DATA_MISMATCH                                 = 0x00006D71,
+    ERROR_ACHIEVEMENTS_WRONG_THREAD                                         = 0x00006D72,
+    ERROR_ACHIEVEMENTS_CALLBACK_IS_NULL                                     = 0x00006D73,
+    ERROR_ACHIEVEMENTS_AUTO_REGISTER_PENDING                                = 0x00006D74,
+    ERROR_ACHIEVEMENTS_NOT_INITIALIZED                                      = 0x00006D75,
+    ERROR_ACHIEVEMENTS_ACHIEVEMENT_ID_ALREADY_EXISTS                        = 0x00006D76,
+    ERROR_ACHIEVEMENTS_FAILED_TO_DOWNLOAD_STATIC_DATA                       = 0x00006D77,
+    ERROR_ACHIEVEMENTS_STATIC_DATA_NOT_FOUND                                = 0x00006D78,
+
+    ERROR_GAME_UTILITY_SERVER_VARIABLE_REQUEST_REFUSED                      = 0x000084D1,
+    ERROR_GAME_UTILITY_SERVER_WRONG_NUMBER_OF_VARIABLES_RETURNED            = 0x000084D2,
+    ERROR_GAME_UTILITY_SERVER_CLIENT_REQUEST_REFUSED                        = 0x000084D3,
+    ERROR_GAME_UTILITY_SERVER_PRESENCE_CHANNEL_CREATED_REFUSED              = 0x000084D4,
+    ERROR_GAME_UTILITY_SERVER_VARIABLE_REQUEST_REFUSED_TRANSIENT            = 0x00008502,
+    ERROR_GAME_UTILITY_SERVER_CLIENT_REQUEST_REFUSED_TRANSIENT              = 0x00008503,
+    ERROR_GAME_UTILITY_SERVER_PRESENCE_CHANNEL_CREATED_REFUSED_TRANSIENT    = 0x00008504,
+    ERROR_GAME_UTILITY_SERVER_SERVER_REQUEST_REFUSED_TRANSIENT              = 0x00008505,
+    ERROR_GAME_UTILITY_SERVER_VARIABLE_REQUEST_REFUSED_BUSY                 = 0x00008534,
+    ERROR_GAME_UTILITY_SERVER_CLIENT_REQUEST_REFUSED_BUSY                   = 0x00008535,
+    ERROR_GAME_UTILITY_SERVER_PRESENCE_CHANNEL_CREATED_REFUSED_BUSY         = 0x00008536,
+    ERROR_GAME_UTILITY_SERVER_SERVER_REQUEST_REFUSED_BUSY                   = 0x00008537,
+    ERROR_GAME_UTILITY_SERVER_NO_SERVER                                     = 0x00008598,
+
+    ERROR_IDENTITY_INSUFFICIENT_DATA                                        = 0x0000A028,
+    ERROR_IDENTITY_TOO_MANY_RESULTS                                         = 0x0000A029,
+    ERROR_IDENTITY_BAD_ID                                                   = 0x0000A02A,
+    ERROR_IDENTITY_NO_ACCOUNT_BLOB                                          = 0x0000A02B,
+
+    ERROR_RISK_CHALLENGE_ACTION                                             = 0x0000A410,
+    ERROR_RISK_DELAY_ACTION                                                 = 0x0000A411,
+    ERROR_RISK_THROTTLE_ACTION                                              = 0x0000A412,
+    ERROR_RISK_ACCOUNT_LOCKED                                               = 0x0000A413,
+    ERROR_RISK_CS_DENIED                                                    = 0x0000A414,
+    ERROR_RISK_DISCONNECT_ACCOUNT                                           = 0x0000A415,
+    ERROR_RISK_CHECK_SKIPPED                                                = 0x0000A416,
+
+    ERROR_REPORT_UNAVAILABLE                                                = 0x0000AFC8,
+    ERROR_REPORT_TOO_LARGE                                                  = 0x0000AFC9,
+    ERROR_REPORT_UNKNOWN_TYPE                                               = 0x0000AFCA,
+    ERROR_REPORT_ATTRIBUTE_INVALID                                          = 0x0000AFCB,
+    ERROR_REPORT_ATTRIBUTE_QUOTA_EXCEEDED                                   = 0x0000AFCC,
+    ERROR_REPORT_UNCONFIRMED                                                = 0x0000AFCD,
+    ERROR_REPORT_NOT_CONNECTED                                              = 0x0000AFCE,
+    ERROR_REPORT_REJECTED                                                   = 0x0000AFCF,
+    ERROR_REPORT_TOO_MANY_REQUESTS                                          = 0x0000AFD0,
+
+    ERROR_ACCOUNT_ALREADY_REGISTERD                                         = 0x0000BB80,
+    ERROR_ACCOUNT_NOT_REGISTERED                                            = 0x0000BB81,
+    ERROR_ACCOUNT_REGISTRATION_PENDING                                      = 0x0000BB82,
+
+    ERROR_MEMCACHED_CLIENT_NO_ERROR                                         = 0x00010000,
+    ERROR_MEMCACHED_CLIENT_KEY_NOT_FOUND                                    = 0x00010001,
+    ERROR_MEMCACHED_KEY_EXISTS                                              = 0x00010002,
+    ERROR_MEMCACHED_VALUE_TO_LARGE                                          = 0x00010003,
+    ERROR_MEMCACHED_INVALID_ARGS                                            = 0x00010004,
+    ERROR_MEMCACHED_ITEM_NOT_STORED                                         = 0x00010005,
+    ERROR_MEMCACHED_NON_NUMERIC_VALUE                                       = 0x00010006,
+    ERROR_MEMCACHED_WRONG_SERVER                                            = 0x00010007,
+    ERROR_MEMCACHED_AUTHENTICATION_ERROR                                    = 0x00010008,
+    ERROR_MEMCACHED_AUTHENTICATION_CONTINUE                                 = 0x00010009,
+    ERROR_MEMCACHED_UNKNOWN_COMMAND                                         = 0x0001000A,
+    ERROR_MEMCACHED_OUT_OF_MEMORY                                           = 0x0001000B,
+    ERROR_MEMCACHED_NOT_SUPPORTED                                           = 0x0001000C,
+    ERROR_MEMCACHED_INTERNAL_ERROR                                          = 0x0001000D,
+    ERROR_MEMCACHED_TEMPORARY_FAILURE                                       = 0x0001000E,
+
+    ERROR_MEMCACHED_CLIENT_ALREADY_CONNECTED                                = 0x000186A0,
+    ERROR_MEMCACHED_CLIENT_BAD_CONFIG                                       = 0x000186A1,
+    ERROR_MEMCACHED_CLIENT_NOT_CONNECTED                                    = 0x000186A2,
+    ERROR_MEMCACHED_CLIENT_TIMEOUT                                          = 0x000186A3,
+    ERROR_MEMCACHED_CLIENT_ABORTED                                          = 0x000186A4,
+
+    ERROR_UTIL_SERVER_FAILED_TO_SERIALIZE                                   = 0x80000064,
+    ERROR_UTIL_SERVER_DISCONNECTED_FROM_BATTLENET                           = 0x80000065,
+    ERROR_UTIL_SERVER_TIMED_OUT                                             = 0x80000066,
+    ERROR_UTIL_SERVER_NO_METERING_DATA                                      = 0x80000067,
+    ERROR_UTIL_SERVER_FAIL_PERMISSION_CHECK                                 = 0x80000068,
+    ERROR_UTIL_SERVER_UNKNOWN_REALM                                         = 0x80000069,
+    ERROR_UTIL_SERVER_MISSING_SESSION_KEY                                   = 0x8000006A,
+    ERROR_UTIL_SERVER_MISSING_VIRTUAL_REALM                                 = 0x8000006B,
+    ERROR_UTIL_SERVER_INVALID_SESSION_KEY                                   = 0x8000006C,
+    ERROR_UTIL_SERVER_MISSING_REALM_LIST                                    = 0x8000006D,
+    ERROR_UTIL_SERVER_INVALID_IDENTITY_ARGS                                 = 0x8000006E,
+    ERROR_UTIL_SERVER_SESSION_OBJECT_MISSING                                = 0x8000006F,
+    ERROR_UTIL_SERVER_INVALID_BNET_SESSION                                  = 0x80000070,
+    ERROR_UTIL_SERVER_INVALID_VIRTUAL_REALM                                 = 0x80000071,
+    ERROR_UTIL_SERVER_INVALID_CLIENT_ADDRESS                                = 0x80000072,
+    ERROR_UTIL_SERVER_FAILED_TO_SERIALIZE_RESPONSE                          = 0x80000073,
+    ERROR_UTIL_SERVER_UNKNOWN_REQUEST                                       = 0x80000074,
+    ERROR_UTIL_SERVER_UNABLE_TO_GENERATE_JOIN_TICKET                        = 0x80000075,
+    ERROR_UTIL_SERVER_UNABLE_TO_GENERATE_REALM_LIST_TICKET                  = 0x80000076,
+    ERROR_UTIL_SERVER_ACCOUNT_DENIED                                        = 0x80000077,
+    ERROR_UTIL_SERVER_INVALID_WOW_ACCOUNT                                   = 0x80000078,
+    ERROR_UTIL_SERVER_UNABLE_TO_STORE_SESSION                               = 0x80000079,
+    ERROR_UTIL_SERVER_SESSION_ALREADY_CREATED                               = 0x8000007A,
+
+    ERROR_USER_SERVER_FAILED_TO_SERIALIZE                                   = 0x800000C8,
+    ERROR_USER_SERVER_DISCONNECTED_FROM_UTIL                                = 0x800000C9,
+    ERROR_USER_SERVER_SESSION_DUPLICATE                                     = 0x800000CA,
+    ERROR_USER_SERVER_FAILED_TO_DISABLE_BILLING                             = 0x800000CB,
+    ERROR_USER_SERVER_PLAYER_DISCONNECTED                                   = 0x800000CC,
+    ERROR_USER_SERVER_FAILED_TO_PARSE_ACCOUNT_STATE                         = 0x800000CD,
+    ERROR_USER_SERVER_ACCOUNT_LOAD_CANCELLED                                = 0x800000CE,
+    ERROR_USER_SERVER_BAD_PLATFORM                                          = 0x800000CF,
+    ERROR_USER_SERVER_BAD_VIRTUAL_REALM                                     = 0x800000D0,
+    ERROR_USER_SERVER_LOCALE_RESTRICTED                                     = 0x800000D1,
+    ERROR_USER_SERVER_MISSING_PROPASS                                       = 0x800000D2,
+    ERROR_USER_SERVER_BAD_WOW_ACCOUNT                                       = 0x800000D3,
+    ERROR_USER_SERVER_BAD_BNET_ACCOUNT                                      = 0x800000D4,
+    ERROR_USER_SERVER_FAILED_TO_PARSE_GAME_ACCOUNT_STATE                    = 0x800000D5,
+    ERROR_USER_SERVER_FAILED_TO_PARSE_GAME_TIME_REMAINING                   = 0x800000D6,
+    ERROR_USER_SERVER_FAILED_TO_PARSE_GAME_SESSION_INFO                     = 0x800000D7,
+    ERROR_USER_SERVER_ACCOUNT_STATE_POORLY_FORMED                           = 0x800000D8,
+    ERROR_USER_SERVER_GAME_ACCOUNT_STATE_POORLY_FORMED                      = 0x800000D9,
+    ERROR_USER_SERVER_GAME_TIME_REMAINING_POORLY_FORMED                     = 0x800000DA,
+    ERROR_USER_SERVER_GAME_SESSION_INFO_POORLY_FORMED                       = 0x800000DB,
+    ERROR_USER_SERVER_BAD_SESSION_TRACKER_STATE                             = 0x800000DC,
+    ERROR_USER_SERVER_FAILED_TO_PARSE_CAIS_INFO                             = 0x800000DD,
+    ERROR_USER_SERVER_GAME_SESSION_DISCONNECTED                             = 0x800000DE,
+    ERROR_USER_SERVER_VERSION_MISMATCH                                      = 0x800000DF,
+    ERROR_USER_SERVER_ACCOUNT_SUSPENDED                                     = 0x800000E0,
+    ERROR_USER_SERVER_NOT_PERMITTED_ON_REALM                                = 0x800000E1,
+    ERROR_USER_SERVER_LOGIN_FAILED_CONNECT                                  = 0x800000E2,
+
+    ERROR_WOW_SERVICES_TIMED_OUT                                            = 0x8000012C,
+    ERROR_WOW_SERVICES_INVALID_REALM_LIST_TICKET                            = 0x8000012D,
+    ERROR_WOW_SERVICES_INVALID_JOIN_TICKET                                  = 0x8000012E,
+    ERROR_WOW_SERVICES_INVALID_SERVER_ADDRESSES                             = 0x8000012F,
+    ERROR_WOW_SERVICES_INVALID_SECRET_BLOB                                  = 0x80000130,
+    ERROR_WOW_SERVICES_NO_REALM_JOIN_IP_FOUND                               = 0x80000131,
+    ERROR_WOW_SERVICES_DENIED_REALM_LIST_TICKET                             = 0x80000132,
+    ERROR_WOW_SERVICES_MISSING_GAME_ACCOUNT                                 = 0x80000133,
+    ERROR_WOW_SERVICES_LOGON_INVALID_AUTH_TOKEN                             = 0x80000134,
+    ERROR_WOW_SERVICES_NO_AVAILABLE_REALMS                                  = 0x80000135,
+    ERROR_WOW_SERVICES_FAILED_TO_PARSE_DISPATCH                             = 0x80000136,
+    ERROR_WOW_SERVICES_MISSING_METERING_FILE                                = 0x80000137,
+    ERROR_WOW_SERVICES_LOGIN_INVALID_CONTENT_TYPE                           = 0x80000138,
+    ERROR_WOW_SERVICES_LOGIN_UNABLE_TO_DECODE                               = 0x80000139,
+    ERROR_WOW_SERVICES_LOGIN_POST_ERROR                                     = 0x8000013A,
+    ERROR_WOW_SERVICES_AUTHENTICATOR_PARSE_FAILED                           = 0x8000013B,
+    ERROR_WOW_SERVICES_LEGAL_PARSE_FAILED                                   = 0x8000013C,
+    ERROR_WOW_SERVICES_LOGIN_AUTHENTICATION_PARSE_FAILED                    = 0x8000013D,
+    ERROR_WOW_SERIVCES_USER_MUST_ACCEPT_LEGAL                               = 0x8000013E,
+    ERROR_WOW_SERVICES_DISCONNECTED                                         = 0x8000013F,
+    ERROR_WOW_SERVICES_NO_HANDLER_FOR_DISPATCH                              = 0x80000140,
+    ERROR_WOW_SERVICES_PRE_DISPATCH_HANDLER_FAILED                          = 0x80000141,
+    ERROR_WOW_SERVICES_CRITICAL_STREAMING_ERROR                             = 0x80000142,
+    ERROR_WOW_SERVICES_WORLD_LOAD_ERROR                                     = 0x80000143,
+    ERROR_WOW_SERVICES_LOGIN_FAILED                                         = 0x80000144,
+    ERROR_WOW_SERVICES_LOGIN_FAILED_ON_CHALLENGE                            = 0x80000145,
+    ERROR_WOW_SERVICES_NO_PREPAID_TIME                                      = 0x80000146,
+    ERROR_WOW_SERVICES_SUBSCRIPTION_EXPIRED                                 = 0x80000147,
+    ERROR_WOW_SERVICES_CANT_CONNECT                                         = 0x80000148,
+};
+#endif // BattlenetRpcErrorCodes_h__
diff --git a/src/server/proto/CMakeLists.txt b/src/server/proto/CMakeLists.txt
new file mode 100644
index 00000000000..fd20378084f
--- /dev/null
+++ b/src/server/proto/CMakeLists.txt
@@ -0,0 +1,62 @@
+# Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
+#
+# This file is free software; as a special exception the author gives
+# unlimited permission to copy and/or distribute it, with or without
+# modifications, as long as this notice is preserved.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+if (MSVC)
+  add_definitions(/W0)
+else()
+  add_definitions(-w)
+endif()
+
+CollectSourceFiles(
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  PRIVATE_SOURCES
+  # Exclude
+  ${CMAKE_CURRENT_SOURCE_DIR}/PrecompiledHeaders)
+
+if (USE_COREPCH)
+  set(PRIVATE_PCH_HEADER PrecompiledHeaders/protoPCH.h)
+  set(PRIVATE_PCH_SOURCE PrecompiledHeaders/protoPCH.cpp)
+endif()
+
+GroupSources(${CMAKE_CURRENT_SOURCE_DIR})
+
+add_definitions(-DTRINITY_API_EXPORT_SHARED)
+
+add_library(proto STATIC
+  ${PRIVATE_SOURCES}
+  ${PRIVATE_PCH_SOURCE}
+)
+
+CollectIncludeDirectories(
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  PUBLIC_INCLUDES
+  # Exclude
+  ${CMAKE_CURRENT_SOURCE_DIR}/PrecompiledHeaders)
+
+target_include_directories(proto
+  PUBLIC
+    ${PUBLIC_INCLUDES}
+  PRIVATE
+    ${CMAKE_CURRENT_BINARY_DIR})
+
+target_link_libraries(proto
+  PUBLIC
+    common
+	protobuf)
+
+set_target_properties(proto
+    PROPERTIES
+      FOLDER
+        "server")
+
+# Generate precompiled header
+if (USE_COREPCH)
+  add_cxx_pch(proto ${PRIVATE_PCH_HEADER} ${PRIVATE_PCH_SOURCE})
+endif()
diff --git a/src/server/proto/Client/account_service.pb.cc b/src/server/proto/Client/account_service.pb.cc
new file mode 100644
index 00000000000..85b6c4a53c2
--- /dev/null
+++ b/src/server/proto/Client/account_service.pb.cc
@@ -0,0 +1,11466 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: account_service.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "account_service.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+#include "BattlenetRpcErrorCodes.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace account {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* GetAccountRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetAccountRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetAccountResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetAccountResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CreateGameAccountRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CreateGameAccountRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CacheExpireRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CacheExpireRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CredentialUpdateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CredentialUpdateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CredentialUpdateResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CredentialUpdateResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountFlagUpdateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountFlagUpdateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameAccountFlagUpdateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameAccountFlagUpdateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SubscriptionUpdateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscriptionUpdateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SubscriptionUpdateResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscriptionUpdateResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* IsIgrAddressRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  IsIgrAddressRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountServiceRegion_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountServiceRegion_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountServiceConfig_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountServiceConfig_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetAccountStateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetAccountStateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetAccountStateResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetAccountStateResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetGameAccountStateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetGameAccountStateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetGameAccountStateResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetGameAccountStateResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetLicensesRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetLicensesRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetLicensesResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetLicensesResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetGameSessionInfoRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetGameSessionInfoRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetGameSessionInfoResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetGameSessionInfoResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetGameTimeRemainingInfoRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetGameTimeRemainingInfoRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetGameTimeRemainingInfoResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetGameTimeRemainingInfoResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetCAISInfoRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetCAISInfoRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetCAISInfoResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetCAISInfoResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ForwardCacheExpireRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ForwardCacheExpireRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetAuthorizedDataRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetAuthorizedDataRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetAuthorizedDataResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetAuthorizedDataResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountStateNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountStateNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameAccountStateNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameAccountStateNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameAccountNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameAccountNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameAccountSessionNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameAccountSessionNotification_reflection_ = NULL;
+const ::google::protobuf::ServiceDescriptor* AccountService_descriptor_ = NULL;
+const ::google::protobuf::ServiceDescriptor* AccountListener_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_account_5fservice_2eproto() {
+  protobuf_AddDesc_account_5fservice_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "account_service.proto");
+  GOOGLE_CHECK(file != NULL);
+  GetAccountRequest_descriptor_ = file->message_type(0);
+  static const int GetAccountRequest_offsets_[9] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, ref_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_all_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_blob_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_email_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_battle_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_full_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_links_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, fetch_parental_controls_),
+  };
+  GetAccountRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetAccountRequest_descriptor_,
+      GetAccountRequest::default_instance_,
+      GetAccountRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetAccountRequest));
+  GetAccountResponse_descriptor_ = file->message_type(1);
+  static const int GetAccountResponse_offsets_[7] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, blob_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, email_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, battle_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, full_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, links_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, parental_control_info_),
+  };
+  GetAccountResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetAccountResponse_descriptor_,
+      GetAccountResponse::default_instance_,
+      GetAccountResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetAccountResponse));
+  CreateGameAccountRequest_descriptor_ = file->message_type(2);
+  static const int CreateGameAccountRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, account_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, region_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, realm_permissions_),
+  };
+  CreateGameAccountRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CreateGameAccountRequest_descriptor_,
+      CreateGameAccountRequest::default_instance_,
+      CreateGameAccountRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateGameAccountRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CreateGameAccountRequest));
+  CacheExpireRequest_descriptor_ = file->message_type(3);
+  static const int CacheExpireRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CacheExpireRequest, account_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CacheExpireRequest, game_account_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CacheExpireRequest, email_),
+  };
+  CacheExpireRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CacheExpireRequest_descriptor_,
+      CacheExpireRequest::default_instance_,
+      CacheExpireRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CacheExpireRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CacheExpireRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CacheExpireRequest));
+  CredentialUpdateRequest_descriptor_ = file->message_type(4);
+  static const int CredentialUpdateRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, account_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, old_credentials_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, new_credentials_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, region_),
+  };
+  CredentialUpdateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CredentialUpdateRequest_descriptor_,
+      CredentialUpdateRequest::default_instance_,
+      CredentialUpdateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CredentialUpdateRequest));
+  CredentialUpdateResponse_descriptor_ = file->message_type(5);
+  static const int CredentialUpdateResponse_offsets_[1] = {
+  };
+  CredentialUpdateResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CredentialUpdateResponse_descriptor_,
+      CredentialUpdateResponse::default_instance_,
+      CredentialUpdateResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CredentialUpdateResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CredentialUpdateResponse));
+  AccountFlagUpdateRequest_descriptor_ = file->message_type(6);
+  static const int AccountFlagUpdateRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, account_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, region_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, flag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, active_),
+  };
+  AccountFlagUpdateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountFlagUpdateRequest_descriptor_,
+      AccountFlagUpdateRequest::default_instance_,
+      AccountFlagUpdateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFlagUpdateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountFlagUpdateRequest));
+  GameAccountFlagUpdateRequest_descriptor_ = file->message_type(7);
+  static const int GameAccountFlagUpdateRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFlagUpdateRequest, game_account_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFlagUpdateRequest, flag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFlagUpdateRequest, active_),
+  };
+  GameAccountFlagUpdateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameAccountFlagUpdateRequest_descriptor_,
+      GameAccountFlagUpdateRequest::default_instance_,
+      GameAccountFlagUpdateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFlagUpdateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFlagUpdateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameAccountFlagUpdateRequest));
+  SubscriptionUpdateRequest_descriptor_ = file->message_type(8);
+  static const int SubscriptionUpdateRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriptionUpdateRequest, ref_),
+  };
+  SubscriptionUpdateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscriptionUpdateRequest_descriptor_,
+      SubscriptionUpdateRequest::default_instance_,
+      SubscriptionUpdateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriptionUpdateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriptionUpdateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscriptionUpdateRequest));
+  SubscriptionUpdateResponse_descriptor_ = file->message_type(9);
+  static const int SubscriptionUpdateResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriptionUpdateResponse, ref_),
+  };
+  SubscriptionUpdateResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscriptionUpdateResponse_descriptor_,
+      SubscriptionUpdateResponse::default_instance_,
+      SubscriptionUpdateResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriptionUpdateResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriptionUpdateResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscriptionUpdateResponse));
+  IsIgrAddressRequest_descriptor_ = file->message_type(10);
+  static const int IsIgrAddressRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IsIgrAddressRequest, client_address_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IsIgrAddressRequest, region_),
+  };
+  IsIgrAddressRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      IsIgrAddressRequest_descriptor_,
+      IsIgrAddressRequest::default_instance_,
+      IsIgrAddressRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IsIgrAddressRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(IsIgrAddressRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(IsIgrAddressRequest));
+  AccountServiceRegion_descriptor_ = file->message_type(11);
+  static const int AccountServiceRegion_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceRegion, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceRegion, shard_),
+  };
+  AccountServiceRegion_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountServiceRegion_descriptor_,
+      AccountServiceRegion::default_instance_,
+      AccountServiceRegion_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceRegion, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceRegion, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountServiceRegion));
+  AccountServiceConfig_descriptor_ = file->message_type(12);
+  static const int AccountServiceConfig_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceConfig, region_),
+  };
+  AccountServiceConfig_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountServiceConfig_descriptor_,
+      AccountServiceConfig::default_instance_,
+      AccountServiceConfig_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceConfig, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountServiceConfig, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountServiceConfig));
+  GetAccountStateRequest_descriptor_ = file->message_type(13);
+  static const int GetAccountStateRequest_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateRequest, entity_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateRequest, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateRequest, region_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateRequest, options_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateRequest, tags_),
+  };
+  GetAccountStateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetAccountStateRequest_descriptor_,
+      GetAccountStateRequest::default_instance_,
+      GetAccountStateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetAccountStateRequest));
+  GetAccountStateResponse_descriptor_ = file->message_type(14);
+  static const int GetAccountStateResponse_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateResponse, state_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateResponse, tags_),
+  };
+  GetAccountStateResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetAccountStateResponse_descriptor_,
+      GetAccountStateResponse::default_instance_,
+      GetAccountStateResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAccountStateResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetAccountStateResponse));
+  GetGameAccountStateRequest_descriptor_ = file->message_type(15);
+  static const int GetGameAccountStateRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateRequest, account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateRequest, game_account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateRequest, options_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateRequest, tags_),
+  };
+  GetGameAccountStateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetGameAccountStateRequest_descriptor_,
+      GetGameAccountStateRequest::default_instance_,
+      GetGameAccountStateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetGameAccountStateRequest));
+  GetGameAccountStateResponse_descriptor_ = file->message_type(16);
+  static const int GetGameAccountStateResponse_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateResponse, state_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateResponse, tags_),
+  };
+  GetGameAccountStateResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetGameAccountStateResponse_descriptor_,
+      GetGameAccountStateResponse::default_instance_,
+      GetGameAccountStateResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameAccountStateResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetGameAccountStateResponse));
+  GetLicensesRequest_descriptor_ = file->message_type(17);
+  static const int GetLicensesRequest_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, target_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, fetch_account_licenses_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, fetch_game_account_licenses_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, fetch_dynamic_account_licenses_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, exclude_unknown_program_),
+  };
+  GetLicensesRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetLicensesRequest_descriptor_,
+      GetLicensesRequest::default_instance_,
+      GetLicensesRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetLicensesRequest));
+  GetLicensesResponse_descriptor_ = file->message_type(18);
+  static const int GetLicensesResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesResponse, licenses_),
+  };
+  GetLicensesResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetLicensesResponse_descriptor_,
+      GetLicensesResponse::default_instance_,
+      GetLicensesResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetLicensesResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetLicensesResponse));
+  GetGameSessionInfoRequest_descriptor_ = file->message_type(19);
+  static const int GetGameSessionInfoRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameSessionInfoRequest, entity_id_),
+  };
+  GetGameSessionInfoRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetGameSessionInfoRequest_descriptor_,
+      GetGameSessionInfoRequest::default_instance_,
+      GetGameSessionInfoRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameSessionInfoRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameSessionInfoRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetGameSessionInfoRequest));
+  GetGameSessionInfoResponse_descriptor_ = file->message_type(20);
+  static const int GetGameSessionInfoResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameSessionInfoResponse, session_info_),
+  };
+  GetGameSessionInfoResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetGameSessionInfoResponse_descriptor_,
+      GetGameSessionInfoResponse::default_instance_,
+      GetGameSessionInfoResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameSessionInfoResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameSessionInfoResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetGameSessionInfoResponse));
+  GetGameTimeRemainingInfoRequest_descriptor_ = file->message_type(21);
+  static const int GetGameTimeRemainingInfoRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoRequest, game_account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoRequest, account_id_),
+  };
+  GetGameTimeRemainingInfoRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetGameTimeRemainingInfoRequest_descriptor_,
+      GetGameTimeRemainingInfoRequest::default_instance_,
+      GetGameTimeRemainingInfoRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetGameTimeRemainingInfoRequest));
+  GetGameTimeRemainingInfoResponse_descriptor_ = file->message_type(22);
+  static const int GetGameTimeRemainingInfoResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoResponse, game_time_remaining_info_),
+  };
+  GetGameTimeRemainingInfoResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetGameTimeRemainingInfoResponse_descriptor_,
+      GetGameTimeRemainingInfoResponse::default_instance_,
+      GetGameTimeRemainingInfoResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetGameTimeRemainingInfoResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetGameTimeRemainingInfoResponse));
+  GetCAISInfoRequest_descriptor_ = file->message_type(23);
+  static const int GetCAISInfoRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCAISInfoRequest, entity_id_),
+  };
+  GetCAISInfoRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetCAISInfoRequest_descriptor_,
+      GetCAISInfoRequest::default_instance_,
+      GetCAISInfoRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCAISInfoRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCAISInfoRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetCAISInfoRequest));
+  GetCAISInfoResponse_descriptor_ = file->message_type(24);
+  static const int GetCAISInfoResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCAISInfoResponse, cais_info_),
+  };
+  GetCAISInfoResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetCAISInfoResponse_descriptor_,
+      GetCAISInfoResponse::default_instance_,
+      GetCAISInfoResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCAISInfoResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetCAISInfoResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetCAISInfoResponse));
+  ForwardCacheExpireRequest_descriptor_ = file->message_type(25);
+  static const int ForwardCacheExpireRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ForwardCacheExpireRequest, entity_id_),
+  };
+  ForwardCacheExpireRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ForwardCacheExpireRequest_descriptor_,
+      ForwardCacheExpireRequest::default_instance_,
+      ForwardCacheExpireRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ForwardCacheExpireRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ForwardCacheExpireRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ForwardCacheExpireRequest));
+  GetAuthorizedDataRequest_descriptor_ = file->message_type(26);
+  static const int GetAuthorizedDataRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataRequest, entity_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataRequest, tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataRequest, privileged_network_),
+  };
+  GetAuthorizedDataRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetAuthorizedDataRequest_descriptor_,
+      GetAuthorizedDataRequest::default_instance_,
+      GetAuthorizedDataRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetAuthorizedDataRequest));
+  GetAuthorizedDataResponse_descriptor_ = file->message_type(27);
+  static const int GetAuthorizedDataResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataResponse, data_),
+  };
+  GetAuthorizedDataResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetAuthorizedDataResponse_descriptor_,
+      GetAuthorizedDataResponse::default_instance_,
+      GetAuthorizedDataResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAuthorizedDataResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetAuthorizedDataResponse));
+  AccountStateNotification_descriptor_ = file->message_type(28);
+  static const int AccountStateNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateNotification, account_state_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateNotification, account_tags_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateNotification, subscription_completed_),
+  };
+  AccountStateNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountStateNotification_descriptor_,
+      AccountStateNotification::default_instance_,
+      AccountStateNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountStateNotification));
+  GameAccountStateNotification_descriptor_ = file->message_type(29);
+  static const int GameAccountStateNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateNotification, game_account_state_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateNotification, game_account_tags_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateNotification, subscription_completed_),
+  };
+  GameAccountStateNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameAccountStateNotification_descriptor_,
+      GameAccountStateNotification::default_instance_,
+      GameAccountStateNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameAccountStateNotification));
+  GameAccountNotification_descriptor_ = file->message_type(30);
+  static const int GameAccountNotification_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountNotification, game_accounts_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountNotification, subscriber_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountNotification, account_tags_),
+  };
+  GameAccountNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameAccountNotification_descriptor_,
+      GameAccountNotification::default_instance_,
+      GameAccountNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameAccountNotification));
+  GameAccountSessionNotification_descriptor_ = file->message_type(31);
+  static const int GameAccountSessionNotification_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSessionNotification, game_account_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSessionNotification, session_info_),
+  };
+  GameAccountSessionNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameAccountSessionNotification_descriptor_,
+      GameAccountSessionNotification::default_instance_,
+      GameAccountSessionNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSessionNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSessionNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameAccountSessionNotification));
+  AccountService_descriptor_ = file->service(0);
+  AccountListener_descriptor_ = file->service(1);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_account_5fservice_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetAccountRequest_descriptor_, &GetAccountRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetAccountResponse_descriptor_, &GetAccountResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CreateGameAccountRequest_descriptor_, &CreateGameAccountRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CacheExpireRequest_descriptor_, &CacheExpireRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CredentialUpdateRequest_descriptor_, &CredentialUpdateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CredentialUpdateResponse_descriptor_, &CredentialUpdateResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountFlagUpdateRequest_descriptor_, &AccountFlagUpdateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameAccountFlagUpdateRequest_descriptor_, &GameAccountFlagUpdateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscriptionUpdateRequest_descriptor_, &SubscriptionUpdateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscriptionUpdateResponse_descriptor_, &SubscriptionUpdateResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    IsIgrAddressRequest_descriptor_, &IsIgrAddressRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountServiceRegion_descriptor_, &AccountServiceRegion::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountServiceConfig_descriptor_, &AccountServiceConfig::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetAccountStateRequest_descriptor_, &GetAccountStateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetAccountStateResponse_descriptor_, &GetAccountStateResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetGameAccountStateRequest_descriptor_, &GetGameAccountStateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetGameAccountStateResponse_descriptor_, &GetGameAccountStateResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetLicensesRequest_descriptor_, &GetLicensesRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetLicensesResponse_descriptor_, &GetLicensesResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetGameSessionInfoRequest_descriptor_, &GetGameSessionInfoRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetGameSessionInfoResponse_descriptor_, &GetGameSessionInfoResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetGameTimeRemainingInfoRequest_descriptor_, &GetGameTimeRemainingInfoRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetGameTimeRemainingInfoResponse_descriptor_, &GetGameTimeRemainingInfoResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetCAISInfoRequest_descriptor_, &GetCAISInfoRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetCAISInfoResponse_descriptor_, &GetCAISInfoResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ForwardCacheExpireRequest_descriptor_, &ForwardCacheExpireRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetAuthorizedDataRequest_descriptor_, &GetAuthorizedDataRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetAuthorizedDataResponse_descriptor_, &GetAuthorizedDataResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountStateNotification_descriptor_, &AccountStateNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameAccountStateNotification_descriptor_, &GameAccountStateNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameAccountNotification_descriptor_, &GameAccountNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameAccountSessionNotification_descriptor_, &GameAccountSessionNotification::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_account_5fservice_2eproto() {
+  delete GetAccountRequest::default_instance_;
+  delete GetAccountRequest_reflection_;
+  delete GetAccountResponse::default_instance_;
+  delete GetAccountResponse_reflection_;
+  delete CreateGameAccountRequest::default_instance_;
+  delete CreateGameAccountRequest_reflection_;
+  delete CacheExpireRequest::default_instance_;
+  delete CacheExpireRequest_reflection_;
+  delete CredentialUpdateRequest::default_instance_;
+  delete CredentialUpdateRequest_reflection_;
+  delete CredentialUpdateResponse::default_instance_;
+  delete CredentialUpdateResponse_reflection_;
+  delete AccountFlagUpdateRequest::default_instance_;
+  delete AccountFlagUpdateRequest_reflection_;
+  delete GameAccountFlagUpdateRequest::default_instance_;
+  delete GameAccountFlagUpdateRequest_reflection_;
+  delete SubscriptionUpdateRequest::default_instance_;
+  delete SubscriptionUpdateRequest_reflection_;
+  delete SubscriptionUpdateResponse::default_instance_;
+  delete SubscriptionUpdateResponse_reflection_;
+  delete IsIgrAddressRequest::default_instance_;
+  delete IsIgrAddressRequest_reflection_;
+  delete AccountServiceRegion::default_instance_;
+  delete AccountServiceRegion_reflection_;
+  delete AccountServiceConfig::default_instance_;
+  delete AccountServiceConfig_reflection_;
+  delete GetAccountStateRequest::default_instance_;
+  delete GetAccountStateRequest_reflection_;
+  delete GetAccountStateResponse::default_instance_;
+  delete GetAccountStateResponse_reflection_;
+  delete GetGameAccountStateRequest::default_instance_;
+  delete GetGameAccountStateRequest_reflection_;
+  delete GetGameAccountStateResponse::default_instance_;
+  delete GetGameAccountStateResponse_reflection_;
+  delete GetLicensesRequest::default_instance_;
+  delete GetLicensesRequest_reflection_;
+  delete GetLicensesResponse::default_instance_;
+  delete GetLicensesResponse_reflection_;
+  delete GetGameSessionInfoRequest::default_instance_;
+  delete GetGameSessionInfoRequest_reflection_;
+  delete GetGameSessionInfoResponse::default_instance_;
+  delete GetGameSessionInfoResponse_reflection_;
+  delete GetGameTimeRemainingInfoRequest::default_instance_;
+  delete GetGameTimeRemainingInfoRequest_reflection_;
+  delete GetGameTimeRemainingInfoResponse::default_instance_;
+  delete GetGameTimeRemainingInfoResponse_reflection_;
+  delete GetCAISInfoRequest::default_instance_;
+  delete GetCAISInfoRequest_reflection_;
+  delete GetCAISInfoResponse::default_instance_;
+  delete GetCAISInfoResponse_reflection_;
+  delete ForwardCacheExpireRequest::default_instance_;
+  delete ForwardCacheExpireRequest_reflection_;
+  delete GetAuthorizedDataRequest::default_instance_;
+  delete GetAuthorizedDataRequest_reflection_;
+  delete GetAuthorizedDataResponse::default_instance_;
+  delete GetAuthorizedDataResponse_reflection_;
+  delete AccountStateNotification::default_instance_;
+  delete AccountStateNotification_reflection_;
+  delete GameAccountStateNotification::default_instance_;
+  delete GameAccountStateNotification_reflection_;
+  delete GameAccountNotification::default_instance_;
+  delete GameAccountNotification_reflection_;
+  delete GameAccountSessionNotification::default_instance_;
+  delete GameAccountSessionNotification_reflection_;
+}
+
+void protobuf_AddDesc_account_5fservice_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::account::v1::protobuf_AddDesc_account_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\025account_service.proto\022\027bgs.protocol.ac"
+    "count.v1\032\023account_types.proto\032\022entity_ty"
+    "pes.proto\032\017rpc_types.proto\"\272\002\n\021GetAccoun"
+    "tRequest\0226\n\003ref\030\001 \001(\0132).bgs.protocol.acc"
+    "ount.v1.AccountReference\022\030\n\tfetch_all\030\n "
+    "\001(\010:\005false\022\031\n\nfetch_blob\030\013 \001(\010:\005false\022\027\n"
+    "\010fetch_id\030\014 \001(\010:\005false\022\032\n\013fetch_email\030\r "
+    "\001(\010:\005false\022\037\n\020fetch_battle_tag\030\016 \001(\010:\005fa"
+    "lse\022\036\n\017fetch_full_name\030\017 \001(\010:\005false\022\032\n\013f"
+    "etch_links\030\020 \001(\010:\005false\022&\n\027fetch_parenta"
+    "l_controls\030\021 \001(\010:\005false\"\264\002\n\022GetAccountRe"
+    "sponse\0222\n\004blob\030\013 \001(\0132$.bgs.protocol.acco"
+    "unt.v1.AccountBlob\022.\n\002id\030\014 \001(\0132\".bgs.pro"
+    "tocol.account.v1.AccountId\022\r\n\005email\030\r \003("
+    "\t\022\022\n\nbattle_tag\030\016 \001(\t\022\021\n\tfull_name\030\017 \001(\t"
+    "\0227\n\005links\030\020 \003(\0132(.bgs.protocol.account.v"
+    "1.GameAccountLink\022K\n\025parental_control_in"
+    "fo\030\021 \001(\0132,.bgs.protocol.account.v1.Paren"
+    "talControlInfo\"\216\001\n\030CreateGameAccountRequ"
+    "est\0223\n\007account\030\001 \001(\0132\".bgs.protocol.acco"
+    "unt.v1.AccountId\022\016\n\006region\030\002 \001(\r\022\017\n\007prog"
+    "ram\030\003 \001(\007\022\034\n\021realm_permissions\030\004 \001(\r:\0011\""
+    "\232\001\n\022CacheExpireRequest\0223\n\007account\030\001 \003(\0132"
+    "\".bgs.protocol.account.v1.AccountId\022@\n\014g"
+    "ame_account\030\002 \003(\0132*.bgs.protocol.account"
+    ".v1.GameAccountHandle\022\r\n\005email\030\003 \003(\t\"\350\001\n"
+    "\027CredentialUpdateRequest\0223\n\007account\030\001 \002("
+    "\0132\".bgs.protocol.account.v1.AccountId\022C\n"
+    "\017old_credentials\030\002 \003(\0132*.bgs.protocol.ac"
+    "count.v1.AccountCredential\022C\n\017new_creden"
+    "tials\030\003 \003(\0132*.bgs.protocol.account.v1.Ac"
+    "countCredential\022\016\n\006region\030\004 \001(\r\"\032\n\030Crede"
+    "ntialUpdateResponse\"}\n\030AccountFlagUpdate"
+    "Request\0223\n\007account\030\001 \001(\0132\".bgs.protocol."
+    "account.v1.AccountId\022\016\n\006region\030\002 \001(\r\022\014\n\004"
+    "flag\030\003 \001(\004\022\016\n\006active\030\004 \001(\010\"~\n\034GameAccoun"
+    "tFlagUpdateRequest\022@\n\014game_account\030\001 \001(\013"
+    "2*.bgs.protocol.account.v1.GameAccountHa"
+    "ndle\022\014\n\004flag\030\002 \001(\004\022\016\n\006active\030\003 \001(\010\"V\n\031Su"
+    "bscriptionUpdateRequest\0229\n\003ref\030\002 \003(\0132,.b"
+    "gs.protocol.account.v1.SubscriberReferen"
+    "ce\"W\n\032SubscriptionUpdateResponse\0229\n\003ref\030"
+    "\001 \003(\0132,.bgs.protocol.account.v1.Subscrib"
+    "erReference\"=\n\023IsIgrAddressRequest\022\026\n\016cl"
+    "ient_address\030\001 \001(\t\022\016\n\006region\030\002 \001(\r\"1\n\024Ac"
+    "countServiceRegion\022\n\n\002id\030\001 \002(\r\022\r\n\005shard\030"
+    "\002 \002(\t\"U\n\024AccountServiceConfig\022=\n\006region\030"
+    "\001 \003(\0132-.bgs.protocol.account.v1.AccountS"
+    "erviceRegion\"\334\001\n\026GetAccountStateRequest\022"
+    ")\n\tentity_id\030\001 \001(\0132\026.bgs.protocol.Entity"
+    "Id\022\017\n\007program\030\002 \001(\r\022\016\n\006region\030\003 \001(\r\022=\n\007o"
+    "ptions\030\n \001(\0132,.bgs.protocol.account.v1.A"
+    "ccountFieldOptions\0227\n\004tags\030\013 \001(\0132).bgs.p"
+    "rotocol.account.v1.AccountFieldTags\"\210\001\n\027"
+    "GetAccountStateResponse\0224\n\005state\030\001 \001(\0132%"
+    ".bgs.protocol.account.v1.AccountState\0227\n"
+    "\004tags\030\002 \001(\0132).bgs.protocol.account.v1.Ac"
+    "countFieldTags\"\375\001\n\032GetGameAccountStateRe"
+    "quest\022.\n\naccount_id\030\001 \001(\0132\026.bgs.protocol"
+    ".EntityIdB\002\030\001\022/\n\017game_account_id\030\002 \001(\0132\026"
+    ".bgs.protocol.EntityId\022A\n\007options\030\n \001(\0132"
+    "0.bgs.protocol.account.v1.GameAccountFie"
+    "ldOptions\022;\n\004tags\030\013 \001(\0132-.bgs.protocol.a"
+    "ccount.v1.GameAccountFieldTags\"\224\001\n\033GetGa"
+    "meAccountStateResponse\0228\n\005state\030\001 \001(\0132)."
+    "bgs.protocol.account.v1.GameAccountState"
+    "\022;\n\004tags\030\002 \001(\0132-.bgs.protocol.account.v1"
+    ".GameAccountFieldTags\"\345\001\n\022GetLicensesReq"
+    "uest\022)\n\ttarget_id\030\001 \001(\0132\026.bgs.protocol.E"
+    "ntityId\022\036\n\026fetch_account_licenses\030\002 \001(\010\022"
+    "#\n\033fetch_game_account_licenses\030\003 \001(\010\022&\n\036"
+    "fetch_dynamic_account_licenses\030\004 \001(\010\022\017\n\007"
+    "program\030\005 \001(\007\022&\n\027exclude_unknown_program"
+    "\030\006 \001(\010:\005false\"P\n\023GetLicensesResponse\0229\n\010"
+    "licenses\030\001 \003(\0132\'.bgs.protocol.account.v1"
+    ".AccountLicense\"F\n\031GetGameSessionInfoReq"
+    "uest\022)\n\tentity_id\030\001 \001(\0132\026.bgs.protocol.E"
+    "ntityId\"\\\n\032GetGameSessionInfoResponse\022>\n"
+    "\014session_info\030\002 \001(\0132(.bgs.protocol.accou"
+    "nt.v1.GameSessionInfo\"~\n\037GetGameTimeRema"
+    "iningInfoRequest\022/\n\017game_account_id\030\001 \001("
+    "\0132\026.bgs.protocol.EntityId\022*\n\naccount_id\030"
+    "\002 \001(\0132\026.bgs.protocol.EntityId\"t\n GetGame"
+    "TimeRemainingInfoResponse\022P\n\030game_time_r"
+    "emaining_info\030\001 \001(\0132..bgs.protocol.accou"
+    "nt.v1.GameTimeRemainingInfo\"\?\n\022GetCAISIn"
+    "foRequest\022)\n\tentity_id\030\001 \001(\0132\026.bgs.proto"
+    "col.EntityId\"G\n\023GetCAISInfoResponse\0220\n\tc"
+    "ais_info\030\001 \001(\0132\035.bgs.protocol.account.v1"
+    ".CAIS\"F\n\031ForwardCacheExpireRequest\022)\n\ten"
+    "tity_id\030\001 \001(\0132\026.bgs.protocol.EntityId\"n\n"
+    "\030GetAuthorizedDataRequest\022)\n\tentity_id\030\001"
+    " \001(\0132\026.bgs.protocol.EntityId\022\013\n\003tag\030\002 \003("
+    "\t\022\032\n\022privileged_network\030\003 \001(\010\"R\n\031GetAuth"
+    "orizedDataResponse\0225\n\004data\030\001 \003(\0132\'.bgs.p"
+    "rotocol.account.v1.AuthorizedData\"\320\001\n\030Ac"
+    "countStateNotification\022<\n\raccount_state\030"
+    "\001 \001(\0132%.bgs.protocol.account.v1.AccountS"
+    "tate\022\025\n\rsubscriber_id\030\002 \001(\004\022\?\n\014account_t"
+    "ags\030\003 \001(\0132).bgs.protocol.account.v1.Acco"
+    "untFieldTags\022\036\n\026subscription_completed\030\004"
+    " \001(\010\"\346\001\n\034GameAccountStateNotification\022E\n"
+    "\022game_account_state\030\001 \001(\0132).bgs.protocol"
+    ".account.v1.GameAccountState\022\025\n\rsubscrib"
+    "er_id\030\002 \001(\004\022H\n\021game_account_tags\030\003 \001(\0132-"
+    ".bgs.protocol.account.v1.GameAccountFiel"
+    "dTags\022\036\n\026subscription_completed\030\004 \001(\010\"\262\001"
+    "\n\027GameAccountNotification\022\?\n\rgame_accoun"
+    "ts\030\001 \003(\0132(.bgs.protocol.account.v1.GameA"
+    "ccountList\022\025\n\rsubscriber_id\030\002 \001(\004\022\?\n\014acc"
+    "ount_tags\030\003 \001(\0132).bgs.protocol.account.v"
+    "1.AccountFieldTags\"\250\001\n\036GameAccountSessio"
+    "nNotification\022@\n\014game_account\030\001 \001(\0132*.bg"
+    "s.protocol.account.v1.GameAccountHandle\022"
+    "D\n\014session_info\030\002 \001(\0132..bgs.protocol.acc"
+    "ount.v1.GameSessionUpdateInfo2\345\020\n\016Accoun"
+    "tService\022l\n\016GetGameAccount\022*.bgs.protoco"
+    "l.account.v1.GameAccountHandle\032(.bgs.pro"
+    "tocol.account.v1.GameAccountBlob\"\004\200\265\030\014\022k"
+    "\n\nGetAccount\022*.bgs.protocol.account.v1.G"
+    "etAccountRequest\032+.bgs.protocol.account."
+    "v1.GetAccountResponse\"\004\200\265\030\r\022x\n\021CreateGam"
+    "eAccount\0221.bgs.protocol.account.v1.Creat"
+    "eGameAccountRequest\032*.bgs.protocol.accou"
+    "nt.v1.GameAccountHandle\"\004\200\265\030\016\022X\n\014IsIgrAd"
+    "dress\022,.bgs.protocol.account.v1.IsIgrAdd"
+    "ressRequest\032\024.bgs.protocol.NoData\"\004\200\265\030\017\022"
+    "[\n\013CacheExpire\022+.bgs.protocol.account.v1"
+    ".CacheExpireRequest\032\031.bgs.protocol.NO_RE"
+    "SPONSE\"\004\200\265\030\024\022}\n\020CredentialUpdate\0220.bgs.p"
+    "rotocol.account.v1.CredentialUpdateReque"
+    "st\0321.bgs.protocol.account.v1.CredentialU"
+    "pdateResponse\"\004\200\265\030\025\022z\n\tSubscribe\0222.bgs.p"
+    "rotocol.account.v1.SubscriptionUpdateReq"
+    "uest\0323.bgs.protocol.account.v1.Subscript"
+    "ionUpdateResponse\"\004\200\265\030\031\022]\n\013Unsubscribe\0222"
+    ".bgs.protocol.account.v1.SubscriptionUpd"
+    "ateRequest\032\024.bgs.protocol.NoData\"\004\200\265\030\032\022z"
+    "\n\017GetAccountState\022/.bgs.protocol.account"
+    ".v1.GetAccountStateRequest\0320.bgs.protoco"
+    "l.account.v1.GetAccountStateResponse\"\004\200\265"
+    "\030\036\022\206\001\n\023GetGameAccountState\0223.bgs.protoco"
+    "l.account.v1.GetGameAccountStateRequest\032"
+    "4.bgs.protocol.account.v1.GetGameAccount"
+    "StateResponse\"\004\200\265\030\037\022n\n\013GetLicenses\022+.bgs"
+    ".protocol.account.v1.GetLicensesRequest\032"
+    ",.bgs.protocol.account.v1.GetLicensesRes"
+    "ponse\"\004\200\265\030 \022\225\001\n\030GetGameTimeRemainingInfo"
+    "\0228.bgs.protocol.account.v1.GetGameTimeRe"
+    "mainingInfoRequest\0329.bgs.protocol.accoun"
+    "t.v1.GetGameTimeRemainingInfoResponse\"\004\200"
+    "\265\030!\022\203\001\n\022GetGameSessionInfo\0222.bgs.protoco"
+    "l.account.v1.GetGameSessionInfoRequest\0323"
+    ".bgs.protocol.account.v1.GetGameSessionI"
+    "nfoResponse\"\004\200\265\030\"\022n\n\013GetCAISInfo\022+.bgs.p"
+    "rotocol.account.v1.GetCAISInfoRequest\032,."
+    "bgs.protocol.account.v1.GetCAISInfoRespo"
+    "nse\"\004\200\265\030#\022d\n\022ForwardCacheExpire\0222.bgs.pr"
+    "otocol.account.v1.ForwardCacheExpireRequ"
+    "est\032\024.bgs.protocol.NoData\"\004\200\265\030$\022\200\001\n\021GetA"
+    "uthorizedData\0221.bgs.protocol.account.v1."
+    "GetAuthorizedDataRequest\0322.bgs.protocol."
+    "account.v1.GetAuthorizedDataResponse\"\004\200\265"
+    "\030%\022g\n\021AccountFlagUpdate\0221.bgs.protocol.a"
+    "ccount.v1.AccountFlagUpdateRequest\032\031.bgs"
+    ".protocol.NO_RESPONSE\"\004\200\265\030&\022o\n\025GameAccou"
+    "ntFlagUpdate\0225.bgs.protocol.account.v1.G"
+    "ameAccountFlagUpdateRequest\032\031.bgs.protoc"
+    "ol.NO_RESPONSE\"\004\200\265\030\'\032\'\312>$bnet.protocol.a"
+    "ccount.AccountService2\377\003\n\017AccountListene"
+    "r\022k\n\025OnAccountStateUpdated\0221.bgs.protoco"
+    "l.account.v1.AccountStateNotification\032\031."
+    "bgs.protocol.NO_RESPONSE\"\004\200\265\030\001\022s\n\031OnGame"
+    "AccountStateUpdated\0225.bgs.protocol.accou"
+    "nt.v1.GameAccountStateNotification\032\031.bgs"
+    ".protocol.NO_RESPONSE\"\004\200\265\030\002\022m\n\025OnGameAcc"
+    "ountsUpdated\0220.bgs.protocol.account.v1.G"
+    "ameAccountNotification\032\031.bgs.protocol.NO"
+    "_RESPONSE\"\007\210\002\001\200\265\030\003\022s\n\024OnGameSessionUpdat"
+    "ed\0227.bgs.protocol.account.v1.GameAccount"
+    "SessionNotification\032\031.bgs.protocol.NO_RE"
+    "SPONSE\"\007\210\002\001\200\265\030\004\032&\312>#bnet.protocol.accoun"
+    "t.AccountNotifyB\005H\001\200\001\000", 7302);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "account_service.proto", &protobuf_RegisterTypes);
+  GetAccountRequest::default_instance_ = new GetAccountRequest();
+  GetAccountResponse::default_instance_ = new GetAccountResponse();
+  CreateGameAccountRequest::default_instance_ = new CreateGameAccountRequest();
+  CacheExpireRequest::default_instance_ = new CacheExpireRequest();
+  CredentialUpdateRequest::default_instance_ = new CredentialUpdateRequest();
+  CredentialUpdateResponse::default_instance_ = new CredentialUpdateResponse();
+  AccountFlagUpdateRequest::default_instance_ = new AccountFlagUpdateRequest();
+  GameAccountFlagUpdateRequest::default_instance_ = new GameAccountFlagUpdateRequest();
+  SubscriptionUpdateRequest::default_instance_ = new SubscriptionUpdateRequest();
+  SubscriptionUpdateResponse::default_instance_ = new SubscriptionUpdateResponse();
+  IsIgrAddressRequest::default_instance_ = new IsIgrAddressRequest();
+  AccountServiceRegion::default_instance_ = new AccountServiceRegion();
+  AccountServiceConfig::default_instance_ = new AccountServiceConfig();
+  GetAccountStateRequest::default_instance_ = new GetAccountStateRequest();
+  GetAccountStateResponse::default_instance_ = new GetAccountStateResponse();
+  GetGameAccountStateRequest::default_instance_ = new GetGameAccountStateRequest();
+  GetGameAccountStateResponse::default_instance_ = new GetGameAccountStateResponse();
+  GetLicensesRequest::default_instance_ = new GetLicensesRequest();
+  GetLicensesResponse::default_instance_ = new GetLicensesResponse();
+  GetGameSessionInfoRequest::default_instance_ = new GetGameSessionInfoRequest();
+  GetGameSessionInfoResponse::default_instance_ = new GetGameSessionInfoResponse();
+  GetGameTimeRemainingInfoRequest::default_instance_ = new GetGameTimeRemainingInfoRequest();
+  GetGameTimeRemainingInfoResponse::default_instance_ = new GetGameTimeRemainingInfoResponse();
+  GetCAISInfoRequest::default_instance_ = new GetCAISInfoRequest();
+  GetCAISInfoResponse::default_instance_ = new GetCAISInfoResponse();
+  ForwardCacheExpireRequest::default_instance_ = new ForwardCacheExpireRequest();
+  GetAuthorizedDataRequest::default_instance_ = new GetAuthorizedDataRequest();
+  GetAuthorizedDataResponse::default_instance_ = new GetAuthorizedDataResponse();
+  AccountStateNotification::default_instance_ = new AccountStateNotification();
+  GameAccountStateNotification::default_instance_ = new GameAccountStateNotification();
+  GameAccountNotification::default_instance_ = new GameAccountNotification();
+  GameAccountSessionNotification::default_instance_ = new GameAccountSessionNotification();
+  GetAccountRequest::default_instance_->InitAsDefaultInstance();
+  GetAccountResponse::default_instance_->InitAsDefaultInstance();
+  CreateGameAccountRequest::default_instance_->InitAsDefaultInstance();
+  CacheExpireRequest::default_instance_->InitAsDefaultInstance();
+  CredentialUpdateRequest::default_instance_->InitAsDefaultInstance();
+  CredentialUpdateResponse::default_instance_->InitAsDefaultInstance();
+  AccountFlagUpdateRequest::default_instance_->InitAsDefaultInstance();
+  GameAccountFlagUpdateRequest::default_instance_->InitAsDefaultInstance();
+  SubscriptionUpdateRequest::default_instance_->InitAsDefaultInstance();
+  SubscriptionUpdateResponse::default_instance_->InitAsDefaultInstance();
+  IsIgrAddressRequest::default_instance_->InitAsDefaultInstance();
+  AccountServiceRegion::default_instance_->InitAsDefaultInstance();
+  AccountServiceConfig::default_instance_->InitAsDefaultInstance();
+  GetAccountStateRequest::default_instance_->InitAsDefaultInstance();
+  GetAccountStateResponse::default_instance_->InitAsDefaultInstance();
+  GetGameAccountStateRequest::default_instance_->InitAsDefaultInstance();
+  GetGameAccountStateResponse::default_instance_->InitAsDefaultInstance();
+  GetLicensesRequest::default_instance_->InitAsDefaultInstance();
+  GetLicensesResponse::default_instance_->InitAsDefaultInstance();
+  GetGameSessionInfoRequest::default_instance_->InitAsDefaultInstance();
+  GetGameSessionInfoResponse::default_instance_->InitAsDefaultInstance();
+  GetGameTimeRemainingInfoRequest::default_instance_->InitAsDefaultInstance();
+  GetGameTimeRemainingInfoResponse::default_instance_->InitAsDefaultInstance();
+  GetCAISInfoRequest::default_instance_->InitAsDefaultInstance();
+  GetCAISInfoResponse::default_instance_->InitAsDefaultInstance();
+  ForwardCacheExpireRequest::default_instance_->InitAsDefaultInstance();
+  GetAuthorizedDataRequest::default_instance_->InitAsDefaultInstance();
+  GetAuthorizedDataResponse::default_instance_->InitAsDefaultInstance();
+  AccountStateNotification::default_instance_->InitAsDefaultInstance();
+  GameAccountStateNotification::default_instance_->InitAsDefaultInstance();
+  GameAccountNotification::default_instance_->InitAsDefaultInstance();
+  GameAccountSessionNotification::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_account_5fservice_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_account_5fservice_2eproto {
+  StaticDescriptorInitializer_account_5fservice_2eproto() {
+    protobuf_AddDesc_account_5fservice_2eproto();
+  }
+} static_descriptor_initializer_account_5fservice_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetAccountRequest::kRefFieldNumber;
+const int GetAccountRequest::kFetchAllFieldNumber;
+const int GetAccountRequest::kFetchBlobFieldNumber;
+const int GetAccountRequest::kFetchIdFieldNumber;
+const int GetAccountRequest::kFetchEmailFieldNumber;
+const int GetAccountRequest::kFetchBattleTagFieldNumber;
+const int GetAccountRequest::kFetchFullNameFieldNumber;
+const int GetAccountRequest::kFetchLinksFieldNumber;
+const int GetAccountRequest::kFetchParentalControlsFieldNumber;
+#endif  // !_MSC_VER
+
+GetAccountRequest::GetAccountRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetAccountRequest)
+}
+
+void GetAccountRequest::InitAsDefaultInstance() {
+  ref_ = const_cast< ::bgs::protocol::account::v1::AccountReference*>(&::bgs::protocol::account::v1::AccountReference::default_instance());
+}
+
+GetAccountRequest::GetAccountRequest(const GetAccountRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetAccountRequest)
+}
+
+void GetAccountRequest::SharedCtor() {
+  _cached_size_ = 0;
+  ref_ = NULL;
+  fetch_all_ = false;
+  fetch_blob_ = false;
+  fetch_id_ = false;
+  fetch_email_ = false;
+  fetch_battle_tag_ = false;
+  fetch_full_name_ = false;
+  fetch_links_ = false;
+  fetch_parental_controls_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetAccountRequest::~GetAccountRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetAccountRequest)
+  SharedDtor();
+}
+
+void GetAccountRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete ref_;
+  }
+}
+
+void GetAccountRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetAccountRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetAccountRequest_descriptor_;
+}
+
+const GetAccountRequest& GetAccountRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetAccountRequest* GetAccountRequest::default_instance_ = NULL;
+
+GetAccountRequest* GetAccountRequest::New() const {
+  return new GetAccountRequest;
+}
+
+void GetAccountRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GetAccountRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 255) {
+    ZR_(fetch_all_, fetch_links_);
+    if (has_ref()) {
+      if (ref_ != NULL) ref_->::bgs::protocol::account::v1::AccountReference::Clear();
+    }
+  }
+  fetch_parental_controls_ = false;
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetAccountRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetAccountRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountReference ref = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_ref()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(80)) goto parse_fetch_all;
+        break;
+      }
+
+      // optional bool fetch_all = 10 [default = false];
+      case 10: {
+        if (tag == 80) {
+         parse_fetch_all:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &fetch_all_)));
+          set_has_fetch_all();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(88)) goto parse_fetch_blob;
+        break;
+      }
+
+      // optional bool fetch_blob = 11 [default = false];
+      case 11: {
+        if (tag == 88) {
+         parse_fetch_blob:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &fetch_blob_)));
+          set_has_fetch_blob();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(96)) goto parse_fetch_id;
+        break;
+      }
+
+      // optional bool fetch_id = 12 [default = false];
+      case 12: {
+        if (tag == 96) {
+         parse_fetch_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &fetch_id_)));
+          set_has_fetch_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(104)) goto parse_fetch_email;
+        break;
+      }
+
+      // optional bool fetch_email = 13 [default = false];
+      case 13: {
+        if (tag == 104) {
+         parse_fetch_email:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &fetch_email_)));
+          set_has_fetch_email();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(112)) goto parse_fetch_battle_tag;
+        break;
+      }
+
+      // optional bool fetch_battle_tag = 14 [default = false];
+      case 14: {
+        if (tag == 112) {
+         parse_fetch_battle_tag:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &fetch_battle_tag_)));
+          set_has_fetch_battle_tag();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(120)) goto parse_fetch_full_name;
+        break;
+      }
+
+      // optional bool fetch_full_name = 15 [default = false];
+      case 15: {
+        if (tag == 120) {
+         parse_fetch_full_name:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &fetch_full_name_)));
+          set_has_fetch_full_name();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(128)) goto parse_fetch_links;
+        break;
+      }
+
+      // optional bool fetch_links = 16 [default = false];
+      case 16: {
+        if (tag == 128) {
+         parse_fetch_links:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &fetch_links_)));
+          set_has_fetch_links();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(136)) goto parse_fetch_parental_controls;
+        break;
+      }
+
+      // optional bool fetch_parental_controls = 17 [default = false];
+      case 17: {
+        if (tag == 136) {
+         parse_fetch_parental_controls:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &fetch_parental_controls_)));
+          set_has_fetch_parental_controls();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetAccountRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetAccountRequest)
+  return false;
+#undef DO_
+}
+
+void GetAccountRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetAccountRequest)
+  // optional .bgs.protocol.account.v1.AccountReference ref = 1;
+  if (has_ref()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->ref(), output);
+  }
+
+  // optional bool fetch_all = 10 [default = false];
+  if (has_fetch_all()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->fetch_all(), output);
+  }
+
+  // optional bool fetch_blob = 11 [default = false];
+  if (has_fetch_blob()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(11, this->fetch_blob(), output);
+  }
+
+  // optional bool fetch_id = 12 [default = false];
+  if (has_fetch_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->fetch_id(), output);
+  }
+
+  // optional bool fetch_email = 13 [default = false];
+  if (has_fetch_email()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(13, this->fetch_email(), output);
+  }
+
+  // optional bool fetch_battle_tag = 14 [default = false];
+  if (has_fetch_battle_tag()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(14, this->fetch_battle_tag(), output);
+  }
+
+  // optional bool fetch_full_name = 15 [default = false];
+  if (has_fetch_full_name()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(15, this->fetch_full_name(), output);
+  }
+
+  // optional bool fetch_links = 16 [default = false];
+  if (has_fetch_links()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(16, this->fetch_links(), output);
+  }
+
+  // optional bool fetch_parental_controls = 17 [default = false];
+  if (has_fetch_parental_controls()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(17, this->fetch_parental_controls(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetAccountRequest)
+}
+
+::google::protobuf::uint8* GetAccountRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetAccountRequest)
+  // optional .bgs.protocol.account.v1.AccountReference ref = 1;
+  if (has_ref()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->ref(), target);
+  }
+
+  // optional bool fetch_all = 10 [default = false];
+  if (has_fetch_all()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->fetch_all(), target);
+  }
+
+  // optional bool fetch_blob = 11 [default = false];
+  if (has_fetch_blob()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(11, this->fetch_blob(), target);
+  }
+
+  // optional bool fetch_id = 12 [default = false];
+  if (has_fetch_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(12, this->fetch_id(), target);
+  }
+
+  // optional bool fetch_email = 13 [default = false];
+  if (has_fetch_email()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(13, this->fetch_email(), target);
+  }
+
+  // optional bool fetch_battle_tag = 14 [default = false];
+  if (has_fetch_battle_tag()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(14, this->fetch_battle_tag(), target);
+  }
+
+  // optional bool fetch_full_name = 15 [default = false];
+  if (has_fetch_full_name()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(15, this->fetch_full_name(), target);
+  }
+
+  // optional bool fetch_links = 16 [default = false];
+  if (has_fetch_links()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(16, this->fetch_links(), target);
+  }
+
+  // optional bool fetch_parental_controls = 17 [default = false];
+  if (has_fetch_parental_controls()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(17, this->fetch_parental_controls(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetAccountRequest)
+  return target;
+}
+
+int GetAccountRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountReference ref = 1;
+    if (has_ref()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->ref());
+    }
+
+    // optional bool fetch_all = 10 [default = false];
+    if (has_fetch_all()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool fetch_blob = 11 [default = false];
+    if (has_fetch_blob()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool fetch_id = 12 [default = false];
+    if (has_fetch_id()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool fetch_email = 13 [default = false];
+    if (has_fetch_email()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool fetch_battle_tag = 14 [default = false];
+    if (has_fetch_battle_tag()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool fetch_full_name = 15 [default = false];
+    if (has_fetch_full_name()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool fetch_links = 16 [default = false];
+    if (has_fetch_links()) {
+      total_size += 2 + 1;
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional bool fetch_parental_controls = 17 [default = false];
+    if (has_fetch_parental_controls()) {
+      total_size += 2 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetAccountRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetAccountRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetAccountRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetAccountRequest::MergeFrom(const GetAccountRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_ref()) {
+      mutable_ref()->::bgs::protocol::account::v1::AccountReference::MergeFrom(from.ref());
+    }
+    if (from.has_fetch_all()) {
+      set_fetch_all(from.fetch_all());
+    }
+    if (from.has_fetch_blob()) {
+      set_fetch_blob(from.fetch_blob());
+    }
+    if (from.has_fetch_id()) {
+      set_fetch_id(from.fetch_id());
+    }
+    if (from.has_fetch_email()) {
+      set_fetch_email(from.fetch_email());
+    }
+    if (from.has_fetch_battle_tag()) {
+      set_fetch_battle_tag(from.fetch_battle_tag());
+    }
+    if (from.has_fetch_full_name()) {
+      set_fetch_full_name(from.fetch_full_name());
+    }
+    if (from.has_fetch_links()) {
+      set_fetch_links(from.fetch_links());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_fetch_parental_controls()) {
+      set_fetch_parental_controls(from.fetch_parental_controls());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetAccountRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetAccountRequest::CopyFrom(const GetAccountRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetAccountRequest::IsInitialized() const {
+
+  if (has_ref()) {
+    if (!this->ref().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetAccountRequest::Swap(GetAccountRequest* other) {
+  if (other != this) {
+    std::swap(ref_, other->ref_);
+    std::swap(fetch_all_, other->fetch_all_);
+    std::swap(fetch_blob_, other->fetch_blob_);
+    std::swap(fetch_id_, other->fetch_id_);
+    std::swap(fetch_email_, other->fetch_email_);
+    std::swap(fetch_battle_tag_, other->fetch_battle_tag_);
+    std::swap(fetch_full_name_, other->fetch_full_name_);
+    std::swap(fetch_links_, other->fetch_links_);
+    std::swap(fetch_parental_controls_, other->fetch_parental_controls_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetAccountRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetAccountRequest_descriptor_;
+  metadata.reflection = GetAccountRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetAccountResponse::kBlobFieldNumber;
+const int GetAccountResponse::kIdFieldNumber;
+const int GetAccountResponse::kEmailFieldNumber;
+const int GetAccountResponse::kBattleTagFieldNumber;
+const int GetAccountResponse::kFullNameFieldNumber;
+const int GetAccountResponse::kLinksFieldNumber;
+const int GetAccountResponse::kParentalControlInfoFieldNumber;
+#endif  // !_MSC_VER
+
+GetAccountResponse::GetAccountResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetAccountResponse)
+}
+
+void GetAccountResponse::InitAsDefaultInstance() {
+  blob_ = const_cast< ::bgs::protocol::account::v1::AccountBlob*>(&::bgs::protocol::account::v1::AccountBlob::default_instance());
+  id_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+  parental_control_info_ = const_cast< ::bgs::protocol::account::v1::ParentalControlInfo*>(&::bgs::protocol::account::v1::ParentalControlInfo::default_instance());
+}
+
+GetAccountResponse::GetAccountResponse(const GetAccountResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetAccountResponse)
+}
+
+void GetAccountResponse::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  blob_ = NULL;
+  id_ = NULL;
+  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  parental_control_info_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetAccountResponse::~GetAccountResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetAccountResponse)
+  SharedDtor();
+}
+
+void GetAccountResponse::SharedDtor() {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete battle_tag_;
+  }
+  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete full_name_;
+  }
+  if (this != default_instance_) {
+    delete blob_;
+    delete id_;
+    delete parental_control_info_;
+  }
+}
+
+void GetAccountResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetAccountResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetAccountResponse_descriptor_;
+}
+
+const GetAccountResponse& GetAccountResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetAccountResponse* GetAccountResponse::default_instance_ = NULL;
+
+GetAccountResponse* GetAccountResponse::New() const {
+  return new GetAccountResponse;
+}
+
+void GetAccountResponse::Clear() {
+  if (_has_bits_[0 / 32] & 91) {
+    if (has_blob()) {
+      if (blob_ != NULL) blob_->::bgs::protocol::account::v1::AccountBlob::Clear();
+    }
+    if (has_id()) {
+      if (id_ != NULL) id_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    if (has_battle_tag()) {
+      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        battle_tag_->clear();
+      }
+    }
+    if (has_full_name()) {
+      if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        full_name_->clear();
+      }
+    }
+    if (has_parental_control_info()) {
+      if (parental_control_info_ != NULL) parental_control_info_->::bgs::protocol::account::v1::ParentalControlInfo::Clear();
+    }
+  }
+  email_.Clear();
+  links_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetAccountResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetAccountResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountBlob blob = 11;
+      case 11: {
+        if (tag == 90) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_blob()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(98)) goto parse_id;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountId id = 12;
+      case 12: {
+        if (tag == 98) {
+         parse_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(106)) goto parse_email;
+        break;
+      }
+
+      // repeated string email = 13;
+      case 13: {
+        if (tag == 106) {
+         parse_email:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_email()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->email(this->email_size() - 1).data(),
+            this->email(this->email_size() - 1).length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "email");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(106)) goto parse_email;
+        if (input->ExpectTag(114)) goto parse_battle_tag;
+        break;
+      }
+
+      // optional string battle_tag = 14;
+      case 14: {
+        if (tag == 114) {
+         parse_battle_tag:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_battle_tag()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->battle_tag().data(), this->battle_tag().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "battle_tag");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(122)) goto parse_full_name;
+        break;
+      }
+
+      // optional string full_name = 15;
+      case 15: {
+        if (tag == 122) {
+         parse_full_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_full_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->full_name().data(), this->full_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "full_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(130)) goto parse_links;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.GameAccountLink links = 16;
+      case 16: {
+        if (tag == 130) {
+         parse_links:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_links()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(130)) goto parse_links;
+        if (input->ExpectTag(138)) goto parse_parental_control_info;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17;
+      case 17: {
+        if (tag == 138) {
+         parse_parental_control_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_parental_control_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetAccountResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetAccountResponse)
+  return false;
+#undef DO_
+}
+
+void GetAccountResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetAccountResponse)
+  // optional .bgs.protocol.account.v1.AccountBlob blob = 11;
+  if (has_blob()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      11, this->blob(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId id = 12;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      12, this->id(), output);
+  }
+
+  // repeated string email = 13;
+  for (int i = 0; i < this->email_size(); i++) {
+  ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+    this->email(i).data(), this->email(i).length(),
+    ::google::protobuf::internal::WireFormat::SERIALIZE,
+    "email");
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      13, this->email(i), output);
+  }
+
+  // optional string battle_tag = 14;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      14, this->battle_tag(), output);
+  }
+
+  // optional string full_name = 15;
+  if (has_full_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->full_name().data(), this->full_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "full_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      15, this->full_name(), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.GameAccountLink links = 16;
+  for (int i = 0; i < this->links_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      16, this->links(i), output);
+  }
+
+  // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17;
+  if (has_parental_control_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      17, this->parental_control_info(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetAccountResponse)
+}
+
+::google::protobuf::uint8* GetAccountResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetAccountResponse)
+  // optional .bgs.protocol.account.v1.AccountBlob blob = 11;
+  if (has_blob()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        11, this->blob(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountId id = 12;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        12, this->id(), target);
+  }
+
+  // repeated string email = 13;
+  for (int i = 0; i < this->email_size(); i++) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->email(i).data(), this->email(i).length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "email");
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteStringToArray(13, this->email(i), target);
+  }
+
+  // optional string battle_tag = 14;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        14, this->battle_tag(), target);
+  }
+
+  // optional string full_name = 15;
+  if (has_full_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->full_name().data(), this->full_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "full_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        15, this->full_name(), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.GameAccountLink links = 16;
+  for (int i = 0; i < this->links_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        16, this->links(i), target);
+  }
+
+  // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17;
+  if (has_parental_control_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        17, this->parental_control_info(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetAccountResponse)
+  return target;
+}
+
+int GetAccountResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountBlob blob = 11;
+    if (has_blob()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->blob());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountId id = 12;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->id());
+    }
+
+    // optional string battle_tag = 14;
+    if (has_battle_tag()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->battle_tag());
+    }
+
+    // optional string full_name = 15;
+    if (has_full_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->full_name());
+    }
+
+    // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17;
+    if (has_parental_control_info()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->parental_control_info());
+    }
+
+  }
+  // repeated string email = 13;
+  total_size += 1 * this->email_size();
+  for (int i = 0; i < this->email_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->email(i));
+  }
+
+  // repeated .bgs.protocol.account.v1.GameAccountLink links = 16;
+  total_size += 2 * this->links_size();
+  for (int i = 0; i < this->links_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->links(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetAccountResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetAccountResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetAccountResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetAccountResponse::MergeFrom(const GetAccountResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  email_.MergeFrom(from.email_);
+  links_.MergeFrom(from.links_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_blob()) {
+      mutable_blob()->::bgs::protocol::account::v1::AccountBlob::MergeFrom(from.blob());
+    }
+    if (from.has_id()) {
+      mutable_id()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.id());
+    }
+    if (from.has_battle_tag()) {
+      set_battle_tag(from.battle_tag());
+    }
+    if (from.has_full_name()) {
+      set_full_name(from.full_name());
+    }
+    if (from.has_parental_control_info()) {
+      mutable_parental_control_info()->::bgs::protocol::account::v1::ParentalControlInfo::MergeFrom(from.parental_control_info());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetAccountResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetAccountResponse::CopyFrom(const GetAccountResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetAccountResponse::IsInitialized() const {
+
+  if (has_blob()) {
+    if (!this->blob().IsInitialized()) return false;
+  }
+  if (has_id()) {
+    if (!this->id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->links())) return false;
+  return true;
+}
+
+void GetAccountResponse::Swap(GetAccountResponse* other) {
+  if (other != this) {
+    std::swap(blob_, other->blob_);
+    std::swap(id_, other->id_);
+    email_.Swap(&other->email_);
+    std::swap(battle_tag_, other->battle_tag_);
+    std::swap(full_name_, other->full_name_);
+    links_.Swap(&other->links_);
+    std::swap(parental_control_info_, other->parental_control_info_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetAccountResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetAccountResponse_descriptor_;
+  metadata.reflection = GetAccountResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CreateGameAccountRequest::kAccountFieldNumber;
+const int CreateGameAccountRequest::kRegionFieldNumber;
+const int CreateGameAccountRequest::kProgramFieldNumber;
+const int CreateGameAccountRequest::kRealmPermissionsFieldNumber;
+#endif  // !_MSC_VER
+
+CreateGameAccountRequest::CreateGameAccountRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.CreateGameAccountRequest)
+}
+
+void CreateGameAccountRequest::InitAsDefaultInstance() {
+  account_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+}
+
+CreateGameAccountRequest::CreateGameAccountRequest(const CreateGameAccountRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.CreateGameAccountRequest)
+}
+
+void CreateGameAccountRequest::SharedCtor() {
+  _cached_size_ = 0;
+  account_ = NULL;
+  region_ = 0u;
+  program_ = 0u;
+  realm_permissions_ = 1u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CreateGameAccountRequest::~CreateGameAccountRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.CreateGameAccountRequest)
+  SharedDtor();
+}
+
+void CreateGameAccountRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete account_;
+  }
+}
+
+void CreateGameAccountRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CreateGameAccountRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CreateGameAccountRequest_descriptor_;
+}
+
+const CreateGameAccountRequest& CreateGameAccountRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+CreateGameAccountRequest* CreateGameAccountRequest::default_instance_ = NULL;
+
+CreateGameAccountRequest* CreateGameAccountRequest::New() const {
+  return new CreateGameAccountRequest;
+}
+
+void CreateGameAccountRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<CreateGameAccountRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(region_, program_);
+    if (has_account()) {
+      if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    realm_permissions_ = 1u;
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CreateGameAccountRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.CreateGameAccountRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId account = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_region;
+        break;
+      }
+
+      // optional uint32 region = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_region:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &region_)));
+          set_has_region();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(29)) goto parse_program;
+        break;
+      }
+
+      // optional fixed32 program = 3;
+      case 3: {
+        if (tag == 29) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_realm_permissions;
+        break;
+      }
+
+      // optional uint32 realm_permissions = 4 [default = 1];
+      case 4: {
+        if (tag == 32) {
+         parse_realm_permissions:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &realm_permissions_)));
+          set_has_realm_permissions();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.CreateGameAccountRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.CreateGameAccountRequest)
+  return false;
+#undef DO_
+}
+
+void CreateGameAccountRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.CreateGameAccountRequest)
+  // optional .bgs.protocol.account.v1.AccountId account = 1;
+  if (has_account()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->account(), output);
+  }
+
+  // optional uint32 region = 2;
+  if (has_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->region(), output);
+  }
+
+  // optional fixed32 program = 3;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->program(), output);
+  }
+
+  // optional uint32 realm_permissions = 4 [default = 1];
+  if (has_realm_permissions()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->realm_permissions(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.CreateGameAccountRequest)
+}
+
+::google::protobuf::uint8* CreateGameAccountRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.CreateGameAccountRequest)
+  // optional .bgs.protocol.account.v1.AccountId account = 1;
+  if (has_account()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->account(), target);
+  }
+
+  // optional uint32 region = 2;
+  if (has_region()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->region(), target);
+  }
+
+  // optional fixed32 program = 3;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->program(), target);
+  }
+
+  // optional uint32 realm_permissions = 4 [default = 1];
+  if (has_realm_permissions()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->realm_permissions(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.CreateGameAccountRequest)
+  return target;
+}
+
+int CreateGameAccountRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId account = 1;
+    if (has_account()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account());
+    }
+
+    // optional uint32 region = 2;
+    if (has_region()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->region());
+    }
+
+    // optional fixed32 program = 3;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+    // optional uint32 realm_permissions = 4 [default = 1];
+    if (has_realm_permissions()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->realm_permissions());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CreateGameAccountRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CreateGameAccountRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CreateGameAccountRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CreateGameAccountRequest::MergeFrom(const CreateGameAccountRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account()) {
+      mutable_account()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.account());
+    }
+    if (from.has_region()) {
+      set_region(from.region());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_realm_permissions()) {
+      set_realm_permissions(from.realm_permissions());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CreateGameAccountRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CreateGameAccountRequest::CopyFrom(const CreateGameAccountRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CreateGameAccountRequest::IsInitialized() const {
+
+  if (has_account()) {
+    if (!this->account().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void CreateGameAccountRequest::Swap(CreateGameAccountRequest* other) {
+  if (other != this) {
+    std::swap(account_, other->account_);
+    std::swap(region_, other->region_);
+    std::swap(program_, other->program_);
+    std::swap(realm_permissions_, other->realm_permissions_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CreateGameAccountRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CreateGameAccountRequest_descriptor_;
+  metadata.reflection = CreateGameAccountRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CacheExpireRequest::kAccountFieldNumber;
+const int CacheExpireRequest::kGameAccountFieldNumber;
+const int CacheExpireRequest::kEmailFieldNumber;
+#endif  // !_MSC_VER
+
+CacheExpireRequest::CacheExpireRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.CacheExpireRequest)
+}
+
+void CacheExpireRequest::InitAsDefaultInstance() {
+}
+
+CacheExpireRequest::CacheExpireRequest(const CacheExpireRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.CacheExpireRequest)
+}
+
+void CacheExpireRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CacheExpireRequest::~CacheExpireRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.CacheExpireRequest)
+  SharedDtor();
+}
+
+void CacheExpireRequest::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void CacheExpireRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CacheExpireRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CacheExpireRequest_descriptor_;
+}
+
+const CacheExpireRequest& CacheExpireRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+CacheExpireRequest* CacheExpireRequest::default_instance_ = NULL;
+
+CacheExpireRequest* CacheExpireRequest::New() const {
+  return new CacheExpireRequest;
+}
+
+void CacheExpireRequest::Clear() {
+  account_.Clear();
+  game_account_.Clear();
+  email_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CacheExpireRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.CacheExpireRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.account.v1.AccountId account = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_account:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_account()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_account;
+        if (input->ExpectTag(18)) goto parse_game_account;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_game_account:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_game_account()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_game_account;
+        if (input->ExpectTag(26)) goto parse_email;
+        break;
+      }
+
+      // repeated string email = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_email:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_email()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->email(this->email_size() - 1).data(),
+            this->email(this->email_size() - 1).length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "email");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_email;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.CacheExpireRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.CacheExpireRequest)
+  return false;
+#undef DO_
+}
+
+void CacheExpireRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.CacheExpireRequest)
+  // repeated .bgs.protocol.account.v1.AccountId account = 1;
+  for (int i = 0; i < this->account_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->account(i), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
+  for (int i = 0; i < this->game_account_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->game_account(i), output);
+  }
+
+  // repeated string email = 3;
+  for (int i = 0; i < this->email_size(); i++) {
+  ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+    this->email(i).data(), this->email(i).length(),
+    ::google::protobuf::internal::WireFormat::SERIALIZE,
+    "email");
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      3, this->email(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.CacheExpireRequest)
+}
+
+::google::protobuf::uint8* CacheExpireRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.CacheExpireRequest)
+  // repeated .bgs.protocol.account.v1.AccountId account = 1;
+  for (int i = 0; i < this->account_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->account(i), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
+  for (int i = 0; i < this->game_account_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->game_account(i), target);
+  }
+
+  // repeated string email = 3;
+  for (int i = 0; i < this->email_size(); i++) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->email(i).data(), this->email(i).length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "email");
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteStringToArray(3, this->email(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.CacheExpireRequest)
+  return target;
+}
+
+int CacheExpireRequest::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.account.v1.AccountId account = 1;
+  total_size += 1 * this->account_size();
+  for (int i = 0; i < this->account_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->account(i));
+  }
+
+  // repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
+  total_size += 1 * this->game_account_size();
+  for (int i = 0; i < this->game_account_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->game_account(i));
+  }
+
+  // repeated string email = 3;
+  total_size += 1 * this->email_size();
+  for (int i = 0; i < this->email_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->email(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CacheExpireRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CacheExpireRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CacheExpireRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CacheExpireRequest::MergeFrom(const CacheExpireRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  account_.MergeFrom(from.account_);
+  game_account_.MergeFrom(from.game_account_);
+  email_.MergeFrom(from.email_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CacheExpireRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CacheExpireRequest::CopyFrom(const CacheExpireRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CacheExpireRequest::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->account())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->game_account())) return false;
+  return true;
+}
+
+void CacheExpireRequest::Swap(CacheExpireRequest* other) {
+  if (other != this) {
+    account_.Swap(&other->account_);
+    game_account_.Swap(&other->game_account_);
+    email_.Swap(&other->email_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CacheExpireRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CacheExpireRequest_descriptor_;
+  metadata.reflection = CacheExpireRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CredentialUpdateRequest::kAccountFieldNumber;
+const int CredentialUpdateRequest::kOldCredentialsFieldNumber;
+const int CredentialUpdateRequest::kNewCredentialsFieldNumber;
+const int CredentialUpdateRequest::kRegionFieldNumber;
+#endif  // !_MSC_VER
+
+CredentialUpdateRequest::CredentialUpdateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.CredentialUpdateRequest)
+}
+
+void CredentialUpdateRequest::InitAsDefaultInstance() {
+  account_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+}
+
+CredentialUpdateRequest::CredentialUpdateRequest(const CredentialUpdateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.CredentialUpdateRequest)
+}
+
+void CredentialUpdateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  account_ = NULL;
+  region_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CredentialUpdateRequest::~CredentialUpdateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.CredentialUpdateRequest)
+  SharedDtor();
+}
+
+void CredentialUpdateRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete account_;
+  }
+}
+
+void CredentialUpdateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CredentialUpdateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CredentialUpdateRequest_descriptor_;
+}
+
+const CredentialUpdateRequest& CredentialUpdateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+CredentialUpdateRequest* CredentialUpdateRequest::default_instance_ = NULL;
+
+CredentialUpdateRequest* CredentialUpdateRequest::New() const {
+  return new CredentialUpdateRequest;
+}
+
+void CredentialUpdateRequest::Clear() {
+  if (_has_bits_[0 / 32] & 9) {
+    if (has_account()) {
+      if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    region_ = 0u;
+  }
+  old_credentials_.Clear();
+  new_credentials_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CredentialUpdateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.CredentialUpdateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.account.v1.AccountId account = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_old_credentials;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_old_credentials:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_old_credentials()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_old_credentials;
+        if (input->ExpectTag(26)) goto parse_new_credentials;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_new_credentials:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_new_credentials()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_new_credentials;
+        if (input->ExpectTag(32)) goto parse_region;
+        break;
+      }
+
+      // optional uint32 region = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_region:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &region_)));
+          set_has_region();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.CredentialUpdateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.CredentialUpdateRequest)
+  return false;
+#undef DO_
+}
+
+void CredentialUpdateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.CredentialUpdateRequest)
+  // required .bgs.protocol.account.v1.AccountId account = 1;
+  if (has_account()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->account(), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2;
+  for (int i = 0; i < this->old_credentials_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->old_credentials(i), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3;
+  for (int i = 0; i < this->new_credentials_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->new_credentials(i), output);
+  }
+
+  // optional uint32 region = 4;
+  if (has_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->region(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.CredentialUpdateRequest)
+}
+
+::google::protobuf::uint8* CredentialUpdateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.CredentialUpdateRequest)
+  // required .bgs.protocol.account.v1.AccountId account = 1;
+  if (has_account()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->account(), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2;
+  for (int i = 0; i < this->old_credentials_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->old_credentials(i), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3;
+  for (int i = 0; i < this->new_credentials_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->new_credentials(i), target);
+  }
+
+  // optional uint32 region = 4;
+  if (has_region()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->region(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.CredentialUpdateRequest)
+  return target;
+}
+
+int CredentialUpdateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.account.v1.AccountId account = 1;
+    if (has_account()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account());
+    }
+
+    // optional uint32 region = 4;
+    if (has_region()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->region());
+    }
+
+  }
+  // repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2;
+  total_size += 1 * this->old_credentials_size();
+  for (int i = 0; i < this->old_credentials_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->old_credentials(i));
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3;
+  total_size += 1 * this->new_credentials_size();
+  for (int i = 0; i < this->new_credentials_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->new_credentials(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CredentialUpdateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CredentialUpdateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CredentialUpdateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CredentialUpdateRequest::MergeFrom(const CredentialUpdateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  old_credentials_.MergeFrom(from.old_credentials_);
+  new_credentials_.MergeFrom(from.new_credentials_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account()) {
+      mutable_account()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.account());
+    }
+    if (from.has_region()) {
+      set_region(from.region());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CredentialUpdateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CredentialUpdateRequest::CopyFrom(const CredentialUpdateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CredentialUpdateRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_account()) {
+    if (!this->account().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->old_credentials())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->new_credentials())) return false;
+  return true;
+}
+
+void CredentialUpdateRequest::Swap(CredentialUpdateRequest* other) {
+  if (other != this) {
+    std::swap(account_, other->account_);
+    old_credentials_.Swap(&other->old_credentials_);
+    new_credentials_.Swap(&other->new_credentials_);
+    std::swap(region_, other->region_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CredentialUpdateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CredentialUpdateRequest_descriptor_;
+  metadata.reflection = CredentialUpdateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+#endif  // !_MSC_VER
+
+CredentialUpdateResponse::CredentialUpdateResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.CredentialUpdateResponse)
+}
+
+void CredentialUpdateResponse::InitAsDefaultInstance() {
+}
+
+CredentialUpdateResponse::CredentialUpdateResponse(const CredentialUpdateResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.CredentialUpdateResponse)
+}
+
+void CredentialUpdateResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CredentialUpdateResponse::~CredentialUpdateResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.CredentialUpdateResponse)
+  SharedDtor();
+}
+
+void CredentialUpdateResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void CredentialUpdateResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CredentialUpdateResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CredentialUpdateResponse_descriptor_;
+}
+
+const CredentialUpdateResponse& CredentialUpdateResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+CredentialUpdateResponse* CredentialUpdateResponse::default_instance_ = NULL;
+
+CredentialUpdateResponse* CredentialUpdateResponse::New() const {
+  return new CredentialUpdateResponse;
+}
+
+void CredentialUpdateResponse::Clear() {
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CredentialUpdateResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.CredentialUpdateResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+  handle_unusual:
+    if (tag == 0 ||
+        ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+      goto success;
+    }
+    DO_(::google::protobuf::internal::WireFormat::SkipField(
+          input, tag, mutable_unknown_fields()));
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.CredentialUpdateResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.CredentialUpdateResponse)
+  return false;
+#undef DO_
+}
+
+void CredentialUpdateResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.CredentialUpdateResponse)
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.CredentialUpdateResponse)
+}
+
+::google::protobuf::uint8* CredentialUpdateResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.CredentialUpdateResponse)
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.CredentialUpdateResponse)
+  return target;
+}
+
+int CredentialUpdateResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CredentialUpdateResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CredentialUpdateResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CredentialUpdateResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CredentialUpdateResponse::MergeFrom(const CredentialUpdateResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CredentialUpdateResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CredentialUpdateResponse::CopyFrom(const CredentialUpdateResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CredentialUpdateResponse::IsInitialized() const {
+
+  return true;
+}
+
+void CredentialUpdateResponse::Swap(CredentialUpdateResponse* other) {
+  if (other != this) {
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CredentialUpdateResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CredentialUpdateResponse_descriptor_;
+  metadata.reflection = CredentialUpdateResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountFlagUpdateRequest::kAccountFieldNumber;
+const int AccountFlagUpdateRequest::kRegionFieldNumber;
+const int AccountFlagUpdateRequest::kFlagFieldNumber;
+const int AccountFlagUpdateRequest::kActiveFieldNumber;
+#endif  // !_MSC_VER
+
+AccountFlagUpdateRequest::AccountFlagUpdateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountFlagUpdateRequest)
+}
+
+void AccountFlagUpdateRequest::InitAsDefaultInstance() {
+  account_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+}
+
+AccountFlagUpdateRequest::AccountFlagUpdateRequest(const AccountFlagUpdateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountFlagUpdateRequest)
+}
+
+void AccountFlagUpdateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  account_ = NULL;
+  region_ = 0u;
+  flag_ = GOOGLE_ULONGLONG(0);
+  active_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountFlagUpdateRequest::~AccountFlagUpdateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountFlagUpdateRequest)
+  SharedDtor();
+}
+
+void AccountFlagUpdateRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete account_;
+  }
+}
+
+void AccountFlagUpdateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountFlagUpdateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountFlagUpdateRequest_descriptor_;
+}
+
+const AccountFlagUpdateRequest& AccountFlagUpdateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+AccountFlagUpdateRequest* AccountFlagUpdateRequest::default_instance_ = NULL;
+
+AccountFlagUpdateRequest* AccountFlagUpdateRequest::New() const {
+  return new AccountFlagUpdateRequest;
+}
+
+void AccountFlagUpdateRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<AccountFlagUpdateRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(flag_, active_);
+    if (has_account()) {
+      if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountFlagUpdateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountFlagUpdateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId account = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_region;
+        break;
+      }
+
+      // optional uint32 region = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_region:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &region_)));
+          set_has_region();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_flag;
+        break;
+      }
+
+      // optional uint64 flag = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_flag:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &flag_)));
+          set_has_flag();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_active;
+        break;
+      }
+
+      // optional bool active = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_active:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &active_)));
+          set_has_active();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountFlagUpdateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountFlagUpdateRequest)
+  return false;
+#undef DO_
+}
+
+void AccountFlagUpdateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountFlagUpdateRequest)
+  // optional .bgs.protocol.account.v1.AccountId account = 1;
+  if (has_account()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->account(), output);
+  }
+
+  // optional uint32 region = 2;
+  if (has_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->region(), output);
+  }
+
+  // optional uint64 flag = 3;
+  if (has_flag()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->flag(), output);
+  }
+
+  // optional bool active = 4;
+  if (has_active()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->active(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountFlagUpdateRequest)
+}
+
+::google::protobuf::uint8* AccountFlagUpdateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountFlagUpdateRequest)
+  // optional .bgs.protocol.account.v1.AccountId account = 1;
+  if (has_account()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->account(), target);
+  }
+
+  // optional uint32 region = 2;
+  if (has_region()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->region(), target);
+  }
+
+  // optional uint64 flag = 3;
+  if (has_flag()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->flag(), target);
+  }
+
+  // optional bool active = 4;
+  if (has_active()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->active(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountFlagUpdateRequest)
+  return target;
+}
+
+int AccountFlagUpdateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId account = 1;
+    if (has_account()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account());
+    }
+
+    // optional uint32 region = 2;
+    if (has_region()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->region());
+    }
+
+    // optional uint64 flag = 3;
+    if (has_flag()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->flag());
+    }
+
+    // optional bool active = 4;
+    if (has_active()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountFlagUpdateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountFlagUpdateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountFlagUpdateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountFlagUpdateRequest::MergeFrom(const AccountFlagUpdateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account()) {
+      mutable_account()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.account());
+    }
+    if (from.has_region()) {
+      set_region(from.region());
+    }
+    if (from.has_flag()) {
+      set_flag(from.flag());
+    }
+    if (from.has_active()) {
+      set_active(from.active());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountFlagUpdateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountFlagUpdateRequest::CopyFrom(const AccountFlagUpdateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountFlagUpdateRequest::IsInitialized() const {
+
+  if (has_account()) {
+    if (!this->account().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AccountFlagUpdateRequest::Swap(AccountFlagUpdateRequest* other) {
+  if (other != this) {
+    std::swap(account_, other->account_);
+    std::swap(region_, other->region_);
+    std::swap(flag_, other->flag_);
+    std::swap(active_, other->active_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountFlagUpdateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountFlagUpdateRequest_descriptor_;
+  metadata.reflection = AccountFlagUpdateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameAccountFlagUpdateRequest::kGameAccountFieldNumber;
+const int GameAccountFlagUpdateRequest::kFlagFieldNumber;
+const int GameAccountFlagUpdateRequest::kActiveFieldNumber;
+#endif  // !_MSC_VER
+
+GameAccountFlagUpdateRequest::GameAccountFlagUpdateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountFlagUpdateRequest)
+}
+
+void GameAccountFlagUpdateRequest::InitAsDefaultInstance() {
+  game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance());
+}
+
+GameAccountFlagUpdateRequest::GameAccountFlagUpdateRequest(const GameAccountFlagUpdateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountFlagUpdateRequest)
+}
+
+void GameAccountFlagUpdateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  game_account_ = NULL;
+  flag_ = GOOGLE_ULONGLONG(0);
+  active_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameAccountFlagUpdateRequest::~GameAccountFlagUpdateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountFlagUpdateRequest)
+  SharedDtor();
+}
+
+void GameAccountFlagUpdateRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete game_account_;
+  }
+}
+
+void GameAccountFlagUpdateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameAccountFlagUpdateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameAccountFlagUpdateRequest_descriptor_;
+}
+
+const GameAccountFlagUpdateRequest& GameAccountFlagUpdateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GameAccountFlagUpdateRequest* GameAccountFlagUpdateRequest::default_instance_ = NULL;
+
+GameAccountFlagUpdateRequest* GameAccountFlagUpdateRequest::New() const {
+  return new GameAccountFlagUpdateRequest;
+}
+
+void GameAccountFlagUpdateRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GameAccountFlagUpdateRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(flag_, active_);
+    if (has_game_account()) {
+      if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameAccountFlagUpdateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountFlagUpdateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_flag;
+        break;
+      }
+
+      // optional uint64 flag = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_flag:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &flag_)));
+          set_has_flag();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_active;
+        break;
+      }
+
+      // optional bool active = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_active:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &active_)));
+          set_has_active();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameAccountFlagUpdateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountFlagUpdateRequest)
+  return false;
+#undef DO_
+}
+
+void GameAccountFlagUpdateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountFlagUpdateRequest)
+  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+  if (has_game_account()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->game_account(), output);
+  }
+
+  // optional uint64 flag = 2;
+  if (has_flag()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->flag(), output);
+  }
+
+  // optional bool active = 3;
+  if (has_active()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->active(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountFlagUpdateRequest)
+}
+
+::google::protobuf::uint8* GameAccountFlagUpdateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountFlagUpdateRequest)
+  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+  if (has_game_account()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->game_account(), target);
+  }
+
+  // optional uint64 flag = 2;
+  if (has_flag()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->flag(), target);
+  }
+
+  // optional bool active = 3;
+  if (has_active()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->active(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountFlagUpdateRequest)
+  return target;
+}
+
+int GameAccountFlagUpdateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+    if (has_game_account()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account());
+    }
+
+    // optional uint64 flag = 2;
+    if (has_flag()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->flag());
+    }
+
+    // optional bool active = 3;
+    if (has_active()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameAccountFlagUpdateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameAccountFlagUpdateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountFlagUpdateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameAccountFlagUpdateRequest::MergeFrom(const GameAccountFlagUpdateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_game_account()) {
+      mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account());
+    }
+    if (from.has_flag()) {
+      set_flag(from.flag());
+    }
+    if (from.has_active()) {
+      set_active(from.active());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameAccountFlagUpdateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameAccountFlagUpdateRequest::CopyFrom(const GameAccountFlagUpdateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameAccountFlagUpdateRequest::IsInitialized() const {
+
+  if (has_game_account()) {
+    if (!this->game_account().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GameAccountFlagUpdateRequest::Swap(GameAccountFlagUpdateRequest* other) {
+  if (other != this) {
+    std::swap(game_account_, other->game_account_);
+    std::swap(flag_, other->flag_);
+    std::swap(active_, other->active_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameAccountFlagUpdateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameAccountFlagUpdateRequest_descriptor_;
+  metadata.reflection = GameAccountFlagUpdateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscriptionUpdateRequest::kRefFieldNumber;
+#endif  // !_MSC_VER
+
+SubscriptionUpdateRequest::SubscriptionUpdateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.SubscriptionUpdateRequest)
+}
+
+void SubscriptionUpdateRequest::InitAsDefaultInstance() {
+}
+
+SubscriptionUpdateRequest::SubscriptionUpdateRequest(const SubscriptionUpdateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.SubscriptionUpdateRequest)
+}
+
+void SubscriptionUpdateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscriptionUpdateRequest::~SubscriptionUpdateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.SubscriptionUpdateRequest)
+  SharedDtor();
+}
+
+void SubscriptionUpdateRequest::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void SubscriptionUpdateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscriptionUpdateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscriptionUpdateRequest_descriptor_;
+}
+
+const SubscriptionUpdateRequest& SubscriptionUpdateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SubscriptionUpdateRequest* SubscriptionUpdateRequest::default_instance_ = NULL;
+
+SubscriptionUpdateRequest* SubscriptionUpdateRequest::New() const {
+  return new SubscriptionUpdateRequest;
+}
+
+void SubscriptionUpdateRequest::Clear() {
+  ref_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscriptionUpdateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.SubscriptionUpdateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.account.v1.SubscriberReference ref = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_ref:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_ref()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_ref;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.SubscriptionUpdateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.SubscriptionUpdateRequest)
+  return false;
+#undef DO_
+}
+
+void SubscriptionUpdateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.SubscriptionUpdateRequest)
+  // repeated .bgs.protocol.account.v1.SubscriberReference ref = 2;
+  for (int i = 0; i < this->ref_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->ref(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.SubscriptionUpdateRequest)
+}
+
+::google::protobuf::uint8* SubscriptionUpdateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.SubscriptionUpdateRequest)
+  // repeated .bgs.protocol.account.v1.SubscriberReference ref = 2;
+  for (int i = 0; i < this->ref_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->ref(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.SubscriptionUpdateRequest)
+  return target;
+}
+
+int SubscriptionUpdateRequest::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.account.v1.SubscriberReference ref = 2;
+  total_size += 1 * this->ref_size();
+  for (int i = 0; i < this->ref_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->ref(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscriptionUpdateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscriptionUpdateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscriptionUpdateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscriptionUpdateRequest::MergeFrom(const SubscriptionUpdateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  ref_.MergeFrom(from.ref_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscriptionUpdateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscriptionUpdateRequest::CopyFrom(const SubscriptionUpdateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscriptionUpdateRequest::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->ref())) return false;
+  return true;
+}
+
+void SubscriptionUpdateRequest::Swap(SubscriptionUpdateRequest* other) {
+  if (other != this) {
+    ref_.Swap(&other->ref_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscriptionUpdateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscriptionUpdateRequest_descriptor_;
+  metadata.reflection = SubscriptionUpdateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscriptionUpdateResponse::kRefFieldNumber;
+#endif  // !_MSC_VER
+
+SubscriptionUpdateResponse::SubscriptionUpdateResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.SubscriptionUpdateResponse)
+}
+
+void SubscriptionUpdateResponse::InitAsDefaultInstance() {
+}
+
+SubscriptionUpdateResponse::SubscriptionUpdateResponse(const SubscriptionUpdateResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.SubscriptionUpdateResponse)
+}
+
+void SubscriptionUpdateResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscriptionUpdateResponse::~SubscriptionUpdateResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.SubscriptionUpdateResponse)
+  SharedDtor();
+}
+
+void SubscriptionUpdateResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void SubscriptionUpdateResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscriptionUpdateResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscriptionUpdateResponse_descriptor_;
+}
+
+const SubscriptionUpdateResponse& SubscriptionUpdateResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SubscriptionUpdateResponse* SubscriptionUpdateResponse::default_instance_ = NULL;
+
+SubscriptionUpdateResponse* SubscriptionUpdateResponse::New() const {
+  return new SubscriptionUpdateResponse;
+}
+
+void SubscriptionUpdateResponse::Clear() {
+  ref_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscriptionUpdateResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.SubscriptionUpdateResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.account.v1.SubscriberReference ref = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_ref:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_ref()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_ref;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.SubscriptionUpdateResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.SubscriptionUpdateResponse)
+  return false;
+#undef DO_
+}
+
+void SubscriptionUpdateResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.SubscriptionUpdateResponse)
+  // repeated .bgs.protocol.account.v1.SubscriberReference ref = 1;
+  for (int i = 0; i < this->ref_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->ref(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.SubscriptionUpdateResponse)
+}
+
+::google::protobuf::uint8* SubscriptionUpdateResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.SubscriptionUpdateResponse)
+  // repeated .bgs.protocol.account.v1.SubscriberReference ref = 1;
+  for (int i = 0; i < this->ref_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->ref(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.SubscriptionUpdateResponse)
+  return target;
+}
+
+int SubscriptionUpdateResponse::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.account.v1.SubscriberReference ref = 1;
+  total_size += 1 * this->ref_size();
+  for (int i = 0; i < this->ref_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->ref(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscriptionUpdateResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscriptionUpdateResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscriptionUpdateResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscriptionUpdateResponse::MergeFrom(const SubscriptionUpdateResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  ref_.MergeFrom(from.ref_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscriptionUpdateResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscriptionUpdateResponse::CopyFrom(const SubscriptionUpdateResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscriptionUpdateResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->ref())) return false;
+  return true;
+}
+
+void SubscriptionUpdateResponse::Swap(SubscriptionUpdateResponse* other) {
+  if (other != this) {
+    ref_.Swap(&other->ref_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscriptionUpdateResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscriptionUpdateResponse_descriptor_;
+  metadata.reflection = SubscriptionUpdateResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int IsIgrAddressRequest::kClientAddressFieldNumber;
+const int IsIgrAddressRequest::kRegionFieldNumber;
+#endif  // !_MSC_VER
+
+IsIgrAddressRequest::IsIgrAddressRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.IsIgrAddressRequest)
+}
+
+void IsIgrAddressRequest::InitAsDefaultInstance() {
+}
+
+IsIgrAddressRequest::IsIgrAddressRequest(const IsIgrAddressRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.IsIgrAddressRequest)
+}
+
+void IsIgrAddressRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  client_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  region_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+IsIgrAddressRequest::~IsIgrAddressRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.IsIgrAddressRequest)
+  SharedDtor();
+}
+
+void IsIgrAddressRequest::SharedDtor() {
+  if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_address_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void IsIgrAddressRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* IsIgrAddressRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return IsIgrAddressRequest_descriptor_;
+}
+
+const IsIgrAddressRequest& IsIgrAddressRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+IsIgrAddressRequest* IsIgrAddressRequest::default_instance_ = NULL;
+
+IsIgrAddressRequest* IsIgrAddressRequest::New() const {
+  return new IsIgrAddressRequest;
+}
+
+void IsIgrAddressRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_client_address()) {
+      if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        client_address_->clear();
+      }
+    }
+    region_ = 0u;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool IsIgrAddressRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.IsIgrAddressRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string client_address = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_client_address()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->client_address().data(), this->client_address().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "client_address");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_region;
+        break;
+      }
+
+      // optional uint32 region = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_region:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &region_)));
+          set_has_region();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.IsIgrAddressRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.IsIgrAddressRequest)
+  return false;
+#undef DO_
+}
+
+void IsIgrAddressRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.IsIgrAddressRequest)
+  // optional string client_address = 1;
+  if (has_client_address()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->client_address().data(), this->client_address().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "client_address");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->client_address(), output);
+  }
+
+  // optional uint32 region = 2;
+  if (has_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->region(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.IsIgrAddressRequest)
+}
+
+::google::protobuf::uint8* IsIgrAddressRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.IsIgrAddressRequest)
+  // optional string client_address = 1;
+  if (has_client_address()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->client_address().data(), this->client_address().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "client_address");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->client_address(), target);
+  }
+
+  // optional uint32 region = 2;
+  if (has_region()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->region(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.IsIgrAddressRequest)
+  return target;
+}
+
+int IsIgrAddressRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string client_address = 1;
+    if (has_client_address()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->client_address());
+    }
+
+    // optional uint32 region = 2;
+    if (has_region()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->region());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void IsIgrAddressRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const IsIgrAddressRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const IsIgrAddressRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void IsIgrAddressRequest::MergeFrom(const IsIgrAddressRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_client_address()) {
+      set_client_address(from.client_address());
+    }
+    if (from.has_region()) {
+      set_region(from.region());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void IsIgrAddressRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void IsIgrAddressRequest::CopyFrom(const IsIgrAddressRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool IsIgrAddressRequest::IsInitialized() const {
+
+  return true;
+}
+
+void IsIgrAddressRequest::Swap(IsIgrAddressRequest* other) {
+  if (other != this) {
+    std::swap(client_address_, other->client_address_);
+    std::swap(region_, other->region_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata IsIgrAddressRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = IsIgrAddressRequest_descriptor_;
+  metadata.reflection = IsIgrAddressRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountServiceRegion::kIdFieldNumber;
+const int AccountServiceRegion::kShardFieldNumber;
+#endif  // !_MSC_VER
+
+AccountServiceRegion::AccountServiceRegion()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountServiceRegion)
+}
+
+void AccountServiceRegion::InitAsDefaultInstance() {
+}
+
+AccountServiceRegion::AccountServiceRegion(const AccountServiceRegion& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountServiceRegion)
+}
+
+void AccountServiceRegion::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = 0u;
+  shard_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountServiceRegion::~AccountServiceRegion() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountServiceRegion)
+  SharedDtor();
+}
+
+void AccountServiceRegion::SharedDtor() {
+  if (shard_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete shard_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void AccountServiceRegion::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountServiceRegion::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountServiceRegion_descriptor_;
+}
+
+const AccountServiceRegion& AccountServiceRegion::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+AccountServiceRegion* AccountServiceRegion::default_instance_ = NULL;
+
+AccountServiceRegion* AccountServiceRegion::New() const {
+  return new AccountServiceRegion;
+}
+
+void AccountServiceRegion::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    id_ = 0u;
+    if (has_shard()) {
+      if (shard_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        shard_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountServiceRegion::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountServiceRegion)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required uint32 id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_shard;
+        break;
+      }
+
+      // required string shard = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_shard:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_shard()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->shard().data(), this->shard().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "shard");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountServiceRegion)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountServiceRegion)
+  return false;
+#undef DO_
+}
+
+void AccountServiceRegion::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountServiceRegion)
+  // required uint32 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output);
+  }
+
+  // required string shard = 2;
+  if (has_shard()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->shard().data(), this->shard().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "shard");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->shard(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountServiceRegion)
+}
+
+::google::protobuf::uint8* AccountServiceRegion::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountServiceRegion)
+  // required uint32 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target);
+  }
+
+  // required string shard = 2;
+  if (has_shard()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->shard().data(), this->shard().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "shard");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->shard(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountServiceRegion)
+  return target;
+}
+
+int AccountServiceRegion::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->id());
+    }
+
+    // required string shard = 2;
+    if (has_shard()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->shard());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountServiceRegion::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountServiceRegion* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountServiceRegion*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountServiceRegion::MergeFrom(const AccountServiceRegion& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_shard()) {
+      set_shard(from.shard());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountServiceRegion::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountServiceRegion::CopyFrom(const AccountServiceRegion& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountServiceRegion::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  return true;
+}
+
+void AccountServiceRegion::Swap(AccountServiceRegion* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(shard_, other->shard_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountServiceRegion::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountServiceRegion_descriptor_;
+  metadata.reflection = AccountServiceRegion_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountServiceConfig::kRegionFieldNumber;
+#endif  // !_MSC_VER
+
+AccountServiceConfig::AccountServiceConfig()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountServiceConfig)
+}
+
+void AccountServiceConfig::InitAsDefaultInstance() {
+}
+
+AccountServiceConfig::AccountServiceConfig(const AccountServiceConfig& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountServiceConfig)
+}
+
+void AccountServiceConfig::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountServiceConfig::~AccountServiceConfig() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountServiceConfig)
+  SharedDtor();
+}
+
+void AccountServiceConfig::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void AccountServiceConfig::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountServiceConfig::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountServiceConfig_descriptor_;
+}
+
+const AccountServiceConfig& AccountServiceConfig::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+AccountServiceConfig* AccountServiceConfig::default_instance_ = NULL;
+
+AccountServiceConfig* AccountServiceConfig::New() const {
+  return new AccountServiceConfig;
+}
+
+void AccountServiceConfig::Clear() {
+  region_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountServiceConfig::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountServiceConfig)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.account.v1.AccountServiceRegion region = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_region:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_region()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_region;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountServiceConfig)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountServiceConfig)
+  return false;
+#undef DO_
+}
+
+void AccountServiceConfig::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountServiceConfig)
+  // repeated .bgs.protocol.account.v1.AccountServiceRegion region = 1;
+  for (int i = 0; i < this->region_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->region(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountServiceConfig)
+}
+
+::google::protobuf::uint8* AccountServiceConfig::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountServiceConfig)
+  // repeated .bgs.protocol.account.v1.AccountServiceRegion region = 1;
+  for (int i = 0; i < this->region_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->region(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountServiceConfig)
+  return target;
+}
+
+int AccountServiceConfig::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.account.v1.AccountServiceRegion region = 1;
+  total_size += 1 * this->region_size();
+  for (int i = 0; i < this->region_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->region(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountServiceConfig::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountServiceConfig* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountServiceConfig*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountServiceConfig::MergeFrom(const AccountServiceConfig& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  region_.MergeFrom(from.region_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountServiceConfig::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountServiceConfig::CopyFrom(const AccountServiceConfig& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountServiceConfig::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->region())) return false;
+  return true;
+}
+
+void AccountServiceConfig::Swap(AccountServiceConfig* other) {
+  if (other != this) {
+    region_.Swap(&other->region_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountServiceConfig::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountServiceConfig_descriptor_;
+  metadata.reflection = AccountServiceConfig_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetAccountStateRequest::kEntityIdFieldNumber;
+const int GetAccountStateRequest::kProgramFieldNumber;
+const int GetAccountStateRequest::kRegionFieldNumber;
+const int GetAccountStateRequest::kOptionsFieldNumber;
+const int GetAccountStateRequest::kTagsFieldNumber;
+#endif  // !_MSC_VER
+
+GetAccountStateRequest::GetAccountStateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetAccountStateRequest)
+}
+
+void GetAccountStateRequest::InitAsDefaultInstance() {
+  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  options_ = const_cast< ::bgs::protocol::account::v1::AccountFieldOptions*>(&::bgs::protocol::account::v1::AccountFieldOptions::default_instance());
+  tags_ = const_cast< ::bgs::protocol::account::v1::AccountFieldTags*>(&::bgs::protocol::account::v1::AccountFieldTags::default_instance());
+}
+
+GetAccountStateRequest::GetAccountStateRequest(const GetAccountStateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetAccountStateRequest)
+}
+
+void GetAccountStateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  entity_id_ = NULL;
+  program_ = 0u;
+  region_ = 0u;
+  options_ = NULL;
+  tags_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetAccountStateRequest::~GetAccountStateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetAccountStateRequest)
+  SharedDtor();
+}
+
+void GetAccountStateRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete entity_id_;
+    delete options_;
+    delete tags_;
+  }
+}
+
+void GetAccountStateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetAccountStateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetAccountStateRequest_descriptor_;
+}
+
+const GetAccountStateRequest& GetAccountStateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetAccountStateRequest* GetAccountStateRequest::default_instance_ = NULL;
+
+GetAccountStateRequest* GetAccountStateRequest::New() const {
+  return new GetAccountStateRequest;
+}
+
+void GetAccountStateRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GetAccountStateRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 31) {
+    ZR_(program_, region_);
+    if (has_entity_id()) {
+      if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::account::v1::AccountFieldOptions::Clear();
+    }
+    if (has_tags()) {
+      if (tags_ != NULL) tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetAccountStateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetAccountStateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId entity_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_program;
+        break;
+      }
+
+      // optional uint32 program = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_region;
+        break;
+      }
+
+      // optional uint32 region = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_region:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &region_)));
+          set_has_region();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountFieldOptions options = 10;
+      case 10: {
+        if (tag == 82) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(90)) goto parse_tags;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountFieldTags tags = 11;
+      case 11: {
+        if (tag == 90) {
+         parse_tags:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_tags()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetAccountStateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetAccountStateRequest)
+  return false;
+#undef DO_
+}
+
+void GetAccountStateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetAccountStateRequest)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->entity_id(), output);
+  }
+
+  // optional uint32 program = 2;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->program(), output);
+  }
+
+  // optional uint32 region = 3;
+  if (has_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->region(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountFieldOptions options = 10;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      10, this->options(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags tags = 11;
+  if (has_tags()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      11, this->tags(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetAccountStateRequest)
+}
+
+::google::protobuf::uint8* GetAccountStateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetAccountStateRequest)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->entity_id(), target);
+  }
+
+  // optional uint32 program = 2;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->program(), target);
+  }
+
+  // optional uint32 region = 3;
+  if (has_region()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->region(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountFieldOptions options = 10;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        10, this->options(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags tags = 11;
+  if (has_tags()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        11, this->tags(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetAccountStateRequest)
+  return target;
+}
+
+int GetAccountStateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId entity_id = 1;
+    if (has_entity_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+    }
+
+    // optional uint32 program = 2;
+    if (has_program()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->program());
+    }
+
+    // optional uint32 region = 3;
+    if (has_region()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->region());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountFieldOptions options = 10;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountFieldTags tags = 11;
+    if (has_tags()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->tags());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetAccountStateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetAccountStateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetAccountStateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetAccountStateRequest::MergeFrom(const GetAccountStateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_entity_id()) {
+      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_region()) {
+      set_region(from.region());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::account::v1::AccountFieldOptions::MergeFrom(from.options());
+    }
+    if (from.has_tags()) {
+      mutable_tags()->::bgs::protocol::account::v1::AccountFieldTags::MergeFrom(from.tags());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetAccountStateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetAccountStateRequest::CopyFrom(const GetAccountStateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetAccountStateRequest::IsInitialized() const {
+
+  if (has_entity_id()) {
+    if (!this->entity_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetAccountStateRequest::Swap(GetAccountStateRequest* other) {
+  if (other != this) {
+    std::swap(entity_id_, other->entity_id_);
+    std::swap(program_, other->program_);
+    std::swap(region_, other->region_);
+    std::swap(options_, other->options_);
+    std::swap(tags_, other->tags_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetAccountStateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetAccountStateRequest_descriptor_;
+  metadata.reflection = GetAccountStateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetAccountStateResponse::kStateFieldNumber;
+const int GetAccountStateResponse::kTagsFieldNumber;
+#endif  // !_MSC_VER
+
+GetAccountStateResponse::GetAccountStateResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetAccountStateResponse)
+}
+
+void GetAccountStateResponse::InitAsDefaultInstance() {
+  state_ = const_cast< ::bgs::protocol::account::v1::AccountState*>(&::bgs::protocol::account::v1::AccountState::default_instance());
+  tags_ = const_cast< ::bgs::protocol::account::v1::AccountFieldTags*>(&::bgs::protocol::account::v1::AccountFieldTags::default_instance());
+}
+
+GetAccountStateResponse::GetAccountStateResponse(const GetAccountStateResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetAccountStateResponse)
+}
+
+void GetAccountStateResponse::SharedCtor() {
+  _cached_size_ = 0;
+  state_ = NULL;
+  tags_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetAccountStateResponse::~GetAccountStateResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetAccountStateResponse)
+  SharedDtor();
+}
+
+void GetAccountStateResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete state_;
+    delete tags_;
+  }
+}
+
+void GetAccountStateResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetAccountStateResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetAccountStateResponse_descriptor_;
+}
+
+const GetAccountStateResponse& GetAccountStateResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetAccountStateResponse* GetAccountStateResponse::default_instance_ = NULL;
+
+GetAccountStateResponse* GetAccountStateResponse::New() const {
+  return new GetAccountStateResponse;
+}
+
+void GetAccountStateResponse::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_state()) {
+      if (state_ != NULL) state_->::bgs::protocol::account::v1::AccountState::Clear();
+    }
+    if (has_tags()) {
+      if (tags_ != NULL) tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetAccountStateResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetAccountStateResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountState state = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_tags;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountFieldTags tags = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_tags:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_tags()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetAccountStateResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetAccountStateResponse)
+  return false;
+#undef DO_
+}
+
+void GetAccountStateResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetAccountStateResponse)
+  // optional .bgs.protocol.account.v1.AccountState state = 1;
+  if (has_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->state(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags tags = 2;
+  if (has_tags()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->tags(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetAccountStateResponse)
+}
+
+::google::protobuf::uint8* GetAccountStateResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetAccountStateResponse)
+  // optional .bgs.protocol.account.v1.AccountState state = 1;
+  if (has_state()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->state(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags tags = 2;
+  if (has_tags()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->tags(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetAccountStateResponse)
+  return target;
+}
+
+int GetAccountStateResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountState state = 1;
+    if (has_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->state());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountFieldTags tags = 2;
+    if (has_tags()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->tags());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetAccountStateResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetAccountStateResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetAccountStateResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetAccountStateResponse::MergeFrom(const GetAccountStateResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_state()) {
+      mutable_state()->::bgs::protocol::account::v1::AccountState::MergeFrom(from.state());
+    }
+    if (from.has_tags()) {
+      mutable_tags()->::bgs::protocol::account::v1::AccountFieldTags::MergeFrom(from.tags());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetAccountStateResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetAccountStateResponse::CopyFrom(const GetAccountStateResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetAccountStateResponse::IsInitialized() const {
+
+  if (has_state()) {
+    if (!this->state().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetAccountStateResponse::Swap(GetAccountStateResponse* other) {
+  if (other != this) {
+    std::swap(state_, other->state_);
+    std::swap(tags_, other->tags_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetAccountStateResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetAccountStateResponse_descriptor_;
+  metadata.reflection = GetAccountStateResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetGameAccountStateRequest::kAccountIdFieldNumber;
+const int GetGameAccountStateRequest::kGameAccountIdFieldNumber;
+const int GetGameAccountStateRequest::kOptionsFieldNumber;
+const int GetGameAccountStateRequest::kTagsFieldNumber;
+#endif  // !_MSC_VER
+
+GetGameAccountStateRequest::GetGameAccountStateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetGameAccountStateRequest)
+}
+
+void GetGameAccountStateRequest::InitAsDefaultInstance() {
+  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  options_ = const_cast< ::bgs::protocol::account::v1::GameAccountFieldOptions*>(&::bgs::protocol::account::v1::GameAccountFieldOptions::default_instance());
+  tags_ = const_cast< ::bgs::protocol::account::v1::GameAccountFieldTags*>(&::bgs::protocol::account::v1::GameAccountFieldTags::default_instance());
+}
+
+GetGameAccountStateRequest::GetGameAccountStateRequest(const GetGameAccountStateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetGameAccountStateRequest)
+}
+
+void GetGameAccountStateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  account_id_ = NULL;
+  game_account_id_ = NULL;
+  options_ = NULL;
+  tags_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetGameAccountStateRequest::~GetGameAccountStateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetGameAccountStateRequest)
+  SharedDtor();
+}
+
+void GetGameAccountStateRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete account_id_;
+    delete game_account_id_;
+    delete options_;
+    delete tags_;
+  }
+}
+
+void GetGameAccountStateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetGameAccountStateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetGameAccountStateRequest_descriptor_;
+}
+
+const GetGameAccountStateRequest& GetGameAccountStateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetGameAccountStateRequest* GetGameAccountStateRequest::default_instance_ = NULL;
+
+GetGameAccountStateRequest* GetGameAccountStateRequest::New() const {
+  return new GetGameAccountStateRequest;
+}
+
+void GetGameAccountStateRequest::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_game_account_id()) {
+      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_options()) {
+      if (options_ != NULL) options_->::bgs::protocol::account::v1::GameAccountFieldOptions::Clear();
+    }
+    if (has_tags()) {
+      if (tags_ != NULL) tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetGameAccountStateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetGameAccountStateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId account_id = 1 [deprecated = true];
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_game_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId game_account_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_game_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_options;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.GameAccountFieldOptions options = 10;
+      case 10: {
+        if (tag == 82) {
+         parse_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(90)) goto parse_tags;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 11;
+      case 11: {
+        if (tag == 90) {
+         parse_tags:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_tags()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetGameAccountStateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetGameAccountStateRequest)
+  return false;
+#undef DO_
+}
+
+void GetGameAccountStateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetGameAccountStateRequest)
+  // optional .bgs.protocol.EntityId account_id = 1 [deprecated = true];
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->account_id(), output);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->game_account_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldOptions options = 10;
+  if (has_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      10, this->options(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 11;
+  if (has_tags()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      11, this->tags(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetGameAccountStateRequest)
+}
+
+::google::protobuf::uint8* GetGameAccountStateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetGameAccountStateRequest)
+  // optional .bgs.protocol.EntityId account_id = 1 [deprecated = true];
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->account_id(), target);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->game_account_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldOptions options = 10;
+  if (has_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        10, this->options(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 11;
+  if (has_tags()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        11, this->tags(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetGameAccountStateRequest)
+  return target;
+}
+
+int GetGameAccountStateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId account_id = 1 [deprecated = true];
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+    // optional .bgs.protocol.EntityId game_account_id = 2;
+    if (has_game_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_id());
+    }
+
+    // optional .bgs.protocol.account.v1.GameAccountFieldOptions options = 10;
+    if (has_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->options());
+    }
+
+    // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 11;
+    if (has_tags()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->tags());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetGameAccountStateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetGameAccountStateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetGameAccountStateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetGameAccountStateRequest::MergeFrom(const GetGameAccountStateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
+    }
+    if (from.has_game_account_id()) {
+      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+    }
+    if (from.has_options()) {
+      mutable_options()->::bgs::protocol::account::v1::GameAccountFieldOptions::MergeFrom(from.options());
+    }
+    if (from.has_tags()) {
+      mutable_tags()->::bgs::protocol::account::v1::GameAccountFieldTags::MergeFrom(from.tags());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetGameAccountStateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetGameAccountStateRequest::CopyFrom(const GetGameAccountStateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetGameAccountStateRequest::IsInitialized() const {
+
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  if (has_game_account_id()) {
+    if (!this->game_account_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetGameAccountStateRequest::Swap(GetGameAccountStateRequest* other) {
+  if (other != this) {
+    std::swap(account_id_, other->account_id_);
+    std::swap(game_account_id_, other->game_account_id_);
+    std::swap(options_, other->options_);
+    std::swap(tags_, other->tags_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetGameAccountStateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetGameAccountStateRequest_descriptor_;
+  metadata.reflection = GetGameAccountStateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetGameAccountStateResponse::kStateFieldNumber;
+const int GetGameAccountStateResponse::kTagsFieldNumber;
+#endif  // !_MSC_VER
+
+GetGameAccountStateResponse::GetGameAccountStateResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetGameAccountStateResponse)
+}
+
+void GetGameAccountStateResponse::InitAsDefaultInstance() {
+  state_ = const_cast< ::bgs::protocol::account::v1::GameAccountState*>(&::bgs::protocol::account::v1::GameAccountState::default_instance());
+  tags_ = const_cast< ::bgs::protocol::account::v1::GameAccountFieldTags*>(&::bgs::protocol::account::v1::GameAccountFieldTags::default_instance());
+}
+
+GetGameAccountStateResponse::GetGameAccountStateResponse(const GetGameAccountStateResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetGameAccountStateResponse)
+}
+
+void GetGameAccountStateResponse::SharedCtor() {
+  _cached_size_ = 0;
+  state_ = NULL;
+  tags_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetGameAccountStateResponse::~GetGameAccountStateResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetGameAccountStateResponse)
+  SharedDtor();
+}
+
+void GetGameAccountStateResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete state_;
+    delete tags_;
+  }
+}
+
+void GetGameAccountStateResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetGameAccountStateResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetGameAccountStateResponse_descriptor_;
+}
+
+const GetGameAccountStateResponse& GetGameAccountStateResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetGameAccountStateResponse* GetGameAccountStateResponse::default_instance_ = NULL;
+
+GetGameAccountStateResponse* GetGameAccountStateResponse::New() const {
+  return new GetGameAccountStateResponse;
+}
+
+void GetGameAccountStateResponse::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_state()) {
+      if (state_ != NULL) state_->::bgs::protocol::account::v1::GameAccountState::Clear();
+    }
+    if (has_tags()) {
+      if (tags_ != NULL) tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetGameAccountStateResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetGameAccountStateResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.GameAccountState state = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_tags;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_tags:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_tags()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetGameAccountStateResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetGameAccountStateResponse)
+  return false;
+#undef DO_
+}
+
+void GetGameAccountStateResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetGameAccountStateResponse)
+  // optional .bgs.protocol.account.v1.GameAccountState state = 1;
+  if (has_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->state(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 2;
+  if (has_tags()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->tags(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetGameAccountStateResponse)
+}
+
+::google::protobuf::uint8* GetGameAccountStateResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetGameAccountStateResponse)
+  // optional .bgs.protocol.account.v1.GameAccountState state = 1;
+  if (has_state()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->state(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 2;
+  if (has_tags()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->tags(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetGameAccountStateResponse)
+  return target;
+}
+
+int GetGameAccountStateResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.GameAccountState state = 1;
+    if (has_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->state());
+    }
+
+    // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 2;
+    if (has_tags()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->tags());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetGameAccountStateResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetGameAccountStateResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetGameAccountStateResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetGameAccountStateResponse::MergeFrom(const GetGameAccountStateResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_state()) {
+      mutable_state()->::bgs::protocol::account::v1::GameAccountState::MergeFrom(from.state());
+    }
+    if (from.has_tags()) {
+      mutable_tags()->::bgs::protocol::account::v1::GameAccountFieldTags::MergeFrom(from.tags());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetGameAccountStateResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetGameAccountStateResponse::CopyFrom(const GetGameAccountStateResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetGameAccountStateResponse::IsInitialized() const {
+
+  if (has_state()) {
+    if (!this->state().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetGameAccountStateResponse::Swap(GetGameAccountStateResponse* other) {
+  if (other != this) {
+    std::swap(state_, other->state_);
+    std::swap(tags_, other->tags_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetGameAccountStateResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetGameAccountStateResponse_descriptor_;
+  metadata.reflection = GetGameAccountStateResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetLicensesRequest::kTargetIdFieldNumber;
+const int GetLicensesRequest::kFetchAccountLicensesFieldNumber;
+const int GetLicensesRequest::kFetchGameAccountLicensesFieldNumber;
+const int GetLicensesRequest::kFetchDynamicAccountLicensesFieldNumber;
+const int GetLicensesRequest::kProgramFieldNumber;
+const int GetLicensesRequest::kExcludeUnknownProgramFieldNumber;
+#endif  // !_MSC_VER
+
+GetLicensesRequest::GetLicensesRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetLicensesRequest)
+}
+
+void GetLicensesRequest::InitAsDefaultInstance() {
+  target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+GetLicensesRequest::GetLicensesRequest(const GetLicensesRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetLicensesRequest)
+}
+
+void GetLicensesRequest::SharedCtor() {
+  _cached_size_ = 0;
+  target_id_ = NULL;
+  fetch_account_licenses_ = false;
+  fetch_game_account_licenses_ = false;
+  fetch_dynamic_account_licenses_ = false;
+  program_ = 0u;
+  exclude_unknown_program_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetLicensesRequest::~GetLicensesRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetLicensesRequest)
+  SharedDtor();
+}
+
+void GetLicensesRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete target_id_;
+  }
+}
+
+void GetLicensesRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetLicensesRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetLicensesRequest_descriptor_;
+}
+
+const GetLicensesRequest& GetLicensesRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetLicensesRequest* GetLicensesRequest::default_instance_ = NULL;
+
+GetLicensesRequest* GetLicensesRequest::New() const {
+  return new GetLicensesRequest;
+}
+
+void GetLicensesRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GetLicensesRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 63) {
+    ZR_(fetch_account_licenses_, program_);
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetLicensesRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetLicensesRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId target_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_fetch_account_licenses;
+        break;
+      }
+
+      // optional bool fetch_account_licenses = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_fetch_account_licenses:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &fetch_account_licenses_)));
+          set_has_fetch_account_licenses();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_fetch_game_account_licenses;
+        break;
+      }
+
+      // optional bool fetch_game_account_licenses = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_fetch_game_account_licenses:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &fetch_game_account_licenses_)));
+          set_has_fetch_game_account_licenses();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_fetch_dynamic_account_licenses;
+        break;
+      }
+
+      // optional bool fetch_dynamic_account_licenses = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_fetch_dynamic_account_licenses:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &fetch_dynamic_account_licenses_)));
+          set_has_fetch_dynamic_account_licenses();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(45)) goto parse_program;
+        break;
+      }
+
+      // optional fixed32 program = 5;
+      case 5: {
+        if (tag == 45) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_exclude_unknown_program;
+        break;
+      }
+
+      // optional bool exclude_unknown_program = 6 [default = false];
+      case 6: {
+        if (tag == 48) {
+         parse_exclude_unknown_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &exclude_unknown_program_)));
+          set_has_exclude_unknown_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetLicensesRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetLicensesRequest)
+  return false;
+#undef DO_
+}
+
+void GetLicensesRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetLicensesRequest)
+  // optional .bgs.protocol.EntityId target_id = 1;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->target_id(), output);
+  }
+
+  // optional bool fetch_account_licenses = 2;
+  if (has_fetch_account_licenses()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->fetch_account_licenses(), output);
+  }
+
+  // optional bool fetch_game_account_licenses = 3;
+  if (has_fetch_game_account_licenses()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->fetch_game_account_licenses(), output);
+  }
+
+  // optional bool fetch_dynamic_account_licenses = 4;
+  if (has_fetch_dynamic_account_licenses()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->fetch_dynamic_account_licenses(), output);
+  }
+
+  // optional fixed32 program = 5;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->program(), output);
+  }
+
+  // optional bool exclude_unknown_program = 6 [default = false];
+  if (has_exclude_unknown_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->exclude_unknown_program(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetLicensesRequest)
+}
+
+::google::protobuf::uint8* GetLicensesRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetLicensesRequest)
+  // optional .bgs.protocol.EntityId target_id = 1;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->target_id(), target);
+  }
+
+  // optional bool fetch_account_licenses = 2;
+  if (has_fetch_account_licenses()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->fetch_account_licenses(), target);
+  }
+
+  // optional bool fetch_game_account_licenses = 3;
+  if (has_fetch_game_account_licenses()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->fetch_game_account_licenses(), target);
+  }
+
+  // optional bool fetch_dynamic_account_licenses = 4;
+  if (has_fetch_dynamic_account_licenses()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->fetch_dynamic_account_licenses(), target);
+  }
+
+  // optional fixed32 program = 5;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->program(), target);
+  }
+
+  // optional bool exclude_unknown_program = 6 [default = false];
+  if (has_exclude_unknown_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->exclude_unknown_program(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetLicensesRequest)
+  return target;
+}
+
+int GetLicensesRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId target_id = 1;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+    // optional bool fetch_account_licenses = 2;
+    if (has_fetch_account_licenses()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool fetch_game_account_licenses = 3;
+    if (has_fetch_game_account_licenses()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool fetch_dynamic_account_licenses = 4;
+    if (has_fetch_dynamic_account_licenses()) {
+      total_size += 1 + 1;
+    }
+
+    // optional fixed32 program = 5;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+    // optional bool exclude_unknown_program = 6 [default = false];
+    if (has_exclude_unknown_program()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetLicensesRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetLicensesRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetLicensesRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetLicensesRequest::MergeFrom(const GetLicensesRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id());
+    }
+    if (from.has_fetch_account_licenses()) {
+      set_fetch_account_licenses(from.fetch_account_licenses());
+    }
+    if (from.has_fetch_game_account_licenses()) {
+      set_fetch_game_account_licenses(from.fetch_game_account_licenses());
+    }
+    if (from.has_fetch_dynamic_account_licenses()) {
+      set_fetch_dynamic_account_licenses(from.fetch_dynamic_account_licenses());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_exclude_unknown_program()) {
+      set_exclude_unknown_program(from.exclude_unknown_program());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetLicensesRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetLicensesRequest::CopyFrom(const GetLicensesRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetLicensesRequest::IsInitialized() const {
+
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetLicensesRequest::Swap(GetLicensesRequest* other) {
+  if (other != this) {
+    std::swap(target_id_, other->target_id_);
+    std::swap(fetch_account_licenses_, other->fetch_account_licenses_);
+    std::swap(fetch_game_account_licenses_, other->fetch_game_account_licenses_);
+    std::swap(fetch_dynamic_account_licenses_, other->fetch_dynamic_account_licenses_);
+    std::swap(program_, other->program_);
+    std::swap(exclude_unknown_program_, other->exclude_unknown_program_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetLicensesRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetLicensesRequest_descriptor_;
+  metadata.reflection = GetLicensesRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetLicensesResponse::kLicensesFieldNumber;
+#endif  // !_MSC_VER
+
+GetLicensesResponse::GetLicensesResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetLicensesResponse)
+}
+
+void GetLicensesResponse::InitAsDefaultInstance() {
+}
+
+GetLicensesResponse::GetLicensesResponse(const GetLicensesResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetLicensesResponse)
+}
+
+void GetLicensesResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetLicensesResponse::~GetLicensesResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetLicensesResponse)
+  SharedDtor();
+}
+
+void GetLicensesResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GetLicensesResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetLicensesResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetLicensesResponse_descriptor_;
+}
+
+const GetLicensesResponse& GetLicensesResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetLicensesResponse* GetLicensesResponse::default_instance_ = NULL;
+
+GetLicensesResponse* GetLicensesResponse::New() const {
+  return new GetLicensesResponse;
+}
+
+void GetLicensesResponse::Clear() {
+  licenses_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetLicensesResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetLicensesResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_licenses:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_licenses()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_licenses;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetLicensesResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetLicensesResponse)
+  return false;
+#undef DO_
+}
+
+void GetLicensesResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetLicensesResponse)
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1;
+  for (int i = 0; i < this->licenses_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->licenses(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetLicensesResponse)
+}
+
+::google::protobuf::uint8* GetLicensesResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetLicensesResponse)
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1;
+  for (int i = 0; i < this->licenses_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->licenses(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetLicensesResponse)
+  return target;
+}
+
+int GetLicensesResponse::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1;
+  total_size += 1 * this->licenses_size();
+  for (int i = 0; i < this->licenses_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->licenses(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetLicensesResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetLicensesResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetLicensesResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetLicensesResponse::MergeFrom(const GetLicensesResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  licenses_.MergeFrom(from.licenses_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetLicensesResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetLicensesResponse::CopyFrom(const GetLicensesResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetLicensesResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->licenses())) return false;
+  return true;
+}
+
+void GetLicensesResponse::Swap(GetLicensesResponse* other) {
+  if (other != this) {
+    licenses_.Swap(&other->licenses_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetLicensesResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetLicensesResponse_descriptor_;
+  metadata.reflection = GetLicensesResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetGameSessionInfoRequest::kEntityIdFieldNumber;
+#endif  // !_MSC_VER
+
+GetGameSessionInfoRequest::GetGameSessionInfoRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetGameSessionInfoRequest)
+}
+
+void GetGameSessionInfoRequest::InitAsDefaultInstance() {
+  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+GetGameSessionInfoRequest::GetGameSessionInfoRequest(const GetGameSessionInfoRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetGameSessionInfoRequest)
+}
+
+void GetGameSessionInfoRequest::SharedCtor() {
+  _cached_size_ = 0;
+  entity_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetGameSessionInfoRequest::~GetGameSessionInfoRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetGameSessionInfoRequest)
+  SharedDtor();
+}
+
+void GetGameSessionInfoRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete entity_id_;
+  }
+}
+
+void GetGameSessionInfoRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetGameSessionInfoRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetGameSessionInfoRequest_descriptor_;
+}
+
+const GetGameSessionInfoRequest& GetGameSessionInfoRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetGameSessionInfoRequest* GetGameSessionInfoRequest::default_instance_ = NULL;
+
+GetGameSessionInfoRequest* GetGameSessionInfoRequest::New() const {
+  return new GetGameSessionInfoRequest;
+}
+
+void GetGameSessionInfoRequest::Clear() {
+  if (has_entity_id()) {
+    if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetGameSessionInfoRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetGameSessionInfoRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId entity_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetGameSessionInfoRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetGameSessionInfoRequest)
+  return false;
+#undef DO_
+}
+
+void GetGameSessionInfoRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetGameSessionInfoRequest)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->entity_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetGameSessionInfoRequest)
+}
+
+::google::protobuf::uint8* GetGameSessionInfoRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetGameSessionInfoRequest)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->entity_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetGameSessionInfoRequest)
+  return target;
+}
+
+int GetGameSessionInfoRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId entity_id = 1;
+    if (has_entity_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetGameSessionInfoRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetGameSessionInfoRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetGameSessionInfoRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetGameSessionInfoRequest::MergeFrom(const GetGameSessionInfoRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_entity_id()) {
+      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetGameSessionInfoRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetGameSessionInfoRequest::CopyFrom(const GetGameSessionInfoRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetGameSessionInfoRequest::IsInitialized() const {
+
+  if (has_entity_id()) {
+    if (!this->entity_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetGameSessionInfoRequest::Swap(GetGameSessionInfoRequest* other) {
+  if (other != this) {
+    std::swap(entity_id_, other->entity_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetGameSessionInfoRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetGameSessionInfoRequest_descriptor_;
+  metadata.reflection = GetGameSessionInfoRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetGameSessionInfoResponse::kSessionInfoFieldNumber;
+#endif  // !_MSC_VER
+
+GetGameSessionInfoResponse::GetGameSessionInfoResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetGameSessionInfoResponse)
+}
+
+void GetGameSessionInfoResponse::InitAsDefaultInstance() {
+  session_info_ = const_cast< ::bgs::protocol::account::v1::GameSessionInfo*>(&::bgs::protocol::account::v1::GameSessionInfo::default_instance());
+}
+
+GetGameSessionInfoResponse::GetGameSessionInfoResponse(const GetGameSessionInfoResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetGameSessionInfoResponse)
+}
+
+void GetGameSessionInfoResponse::SharedCtor() {
+  _cached_size_ = 0;
+  session_info_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetGameSessionInfoResponse::~GetGameSessionInfoResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetGameSessionInfoResponse)
+  SharedDtor();
+}
+
+void GetGameSessionInfoResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete session_info_;
+  }
+}
+
+void GetGameSessionInfoResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetGameSessionInfoResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetGameSessionInfoResponse_descriptor_;
+}
+
+const GetGameSessionInfoResponse& GetGameSessionInfoResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetGameSessionInfoResponse* GetGameSessionInfoResponse::default_instance_ = NULL;
+
+GetGameSessionInfoResponse* GetGameSessionInfoResponse::New() const {
+  return new GetGameSessionInfoResponse;
+}
+
+void GetGameSessionInfoResponse::Clear() {
+  if (has_session_info()) {
+    if (session_info_ != NULL) session_info_->::bgs::protocol::account::v1::GameSessionInfo::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetGameSessionInfoResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetGameSessionInfoResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.GameSessionInfo session_info = 2;
+      case 2: {
+        if (tag == 18) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_session_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetGameSessionInfoResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetGameSessionInfoResponse)
+  return false;
+#undef DO_
+}
+
+void GetGameSessionInfoResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetGameSessionInfoResponse)
+  // optional .bgs.protocol.account.v1.GameSessionInfo session_info = 2;
+  if (has_session_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->session_info(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetGameSessionInfoResponse)
+}
+
+::google::protobuf::uint8* GetGameSessionInfoResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetGameSessionInfoResponse)
+  // optional .bgs.protocol.account.v1.GameSessionInfo session_info = 2;
+  if (has_session_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->session_info(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetGameSessionInfoResponse)
+  return target;
+}
+
+int GetGameSessionInfoResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.GameSessionInfo session_info = 2;
+    if (has_session_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->session_info());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetGameSessionInfoResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetGameSessionInfoResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetGameSessionInfoResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetGameSessionInfoResponse::MergeFrom(const GetGameSessionInfoResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_session_info()) {
+      mutable_session_info()->::bgs::protocol::account::v1::GameSessionInfo::MergeFrom(from.session_info());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetGameSessionInfoResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetGameSessionInfoResponse::CopyFrom(const GetGameSessionInfoResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetGameSessionInfoResponse::IsInitialized() const {
+
+  return true;
+}
+
+void GetGameSessionInfoResponse::Swap(GetGameSessionInfoResponse* other) {
+  if (other != this) {
+    std::swap(session_info_, other->session_info_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetGameSessionInfoResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetGameSessionInfoResponse_descriptor_;
+  metadata.reflection = GetGameSessionInfoResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetGameTimeRemainingInfoRequest::kGameAccountIdFieldNumber;
+const int GetGameTimeRemainingInfoRequest::kAccountIdFieldNumber;
+#endif  // !_MSC_VER
+
+GetGameTimeRemainingInfoRequest::GetGameTimeRemainingInfoRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest)
+}
+
+void GetGameTimeRemainingInfoRequest::InitAsDefaultInstance() {
+  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+GetGameTimeRemainingInfoRequest::GetGameTimeRemainingInfoRequest(const GetGameTimeRemainingInfoRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest)
+}
+
+void GetGameTimeRemainingInfoRequest::SharedCtor() {
+  _cached_size_ = 0;
+  game_account_id_ = NULL;
+  account_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetGameTimeRemainingInfoRequest::~GetGameTimeRemainingInfoRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest)
+  SharedDtor();
+}
+
+void GetGameTimeRemainingInfoRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete game_account_id_;
+    delete account_id_;
+  }
+}
+
+void GetGameTimeRemainingInfoRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetGameTimeRemainingInfoRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetGameTimeRemainingInfoRequest_descriptor_;
+}
+
+const GetGameTimeRemainingInfoRequest& GetGameTimeRemainingInfoRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetGameTimeRemainingInfoRequest* GetGameTimeRemainingInfoRequest::default_instance_ = NULL;
+
+GetGameTimeRemainingInfoRequest* GetGameTimeRemainingInfoRequest::New() const {
+  return new GetGameTimeRemainingInfoRequest;
+}
+
+void GetGameTimeRemainingInfoRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_game_account_id()) {
+      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetGameTimeRemainingInfoRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId game_account_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId account_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest)
+  return false;
+#undef DO_
+}
+
+void GetGameTimeRemainingInfoRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest)
+  // optional .bgs.protocol.EntityId game_account_id = 1;
+  if (has_game_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->game_account_id(), output);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 2;
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->account_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest)
+}
+
+::google::protobuf::uint8* GetGameTimeRemainingInfoRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest)
+  // optional .bgs.protocol.EntityId game_account_id = 1;
+  if (has_game_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->game_account_id(), target);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 2;
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->account_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest)
+  return target;
+}
+
+int GetGameTimeRemainingInfoRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId game_account_id = 1;
+    if (has_game_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_id());
+    }
+
+    // optional .bgs.protocol.EntityId account_id = 2;
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetGameTimeRemainingInfoRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetGameTimeRemainingInfoRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetGameTimeRemainingInfoRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetGameTimeRemainingInfoRequest::MergeFrom(const GetGameTimeRemainingInfoRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_game_account_id()) {
+      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+    }
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetGameTimeRemainingInfoRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetGameTimeRemainingInfoRequest::CopyFrom(const GetGameTimeRemainingInfoRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetGameTimeRemainingInfoRequest::IsInitialized() const {
+
+  if (has_game_account_id()) {
+    if (!this->game_account_id().IsInitialized()) return false;
+  }
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetGameTimeRemainingInfoRequest::Swap(GetGameTimeRemainingInfoRequest* other) {
+  if (other != this) {
+    std::swap(game_account_id_, other->game_account_id_);
+    std::swap(account_id_, other->account_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetGameTimeRemainingInfoRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetGameTimeRemainingInfoRequest_descriptor_;
+  metadata.reflection = GetGameTimeRemainingInfoRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetGameTimeRemainingInfoResponse::kGameTimeRemainingInfoFieldNumber;
+#endif  // !_MSC_VER
+
+GetGameTimeRemainingInfoResponse::GetGameTimeRemainingInfoResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse)
+}
+
+void GetGameTimeRemainingInfoResponse::InitAsDefaultInstance() {
+  game_time_remaining_info_ = const_cast< ::bgs::protocol::account::v1::GameTimeRemainingInfo*>(&::bgs::protocol::account::v1::GameTimeRemainingInfo::default_instance());
+}
+
+GetGameTimeRemainingInfoResponse::GetGameTimeRemainingInfoResponse(const GetGameTimeRemainingInfoResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse)
+}
+
+void GetGameTimeRemainingInfoResponse::SharedCtor() {
+  _cached_size_ = 0;
+  game_time_remaining_info_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetGameTimeRemainingInfoResponse::~GetGameTimeRemainingInfoResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse)
+  SharedDtor();
+}
+
+void GetGameTimeRemainingInfoResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete game_time_remaining_info_;
+  }
+}
+
+void GetGameTimeRemainingInfoResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetGameTimeRemainingInfoResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetGameTimeRemainingInfoResponse_descriptor_;
+}
+
+const GetGameTimeRemainingInfoResponse& GetGameTimeRemainingInfoResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetGameTimeRemainingInfoResponse* GetGameTimeRemainingInfoResponse::default_instance_ = NULL;
+
+GetGameTimeRemainingInfoResponse* GetGameTimeRemainingInfoResponse::New() const {
+  return new GetGameTimeRemainingInfoResponse;
+}
+
+void GetGameTimeRemainingInfoResponse::Clear() {
+  if (has_game_time_remaining_info()) {
+    if (game_time_remaining_info_ != NULL) game_time_remaining_info_->::bgs::protocol::account::v1::GameTimeRemainingInfo::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetGameTimeRemainingInfoResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.GameTimeRemainingInfo game_time_remaining_info = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_time_remaining_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse)
+  return false;
+#undef DO_
+}
+
+void GetGameTimeRemainingInfoResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse)
+  // optional .bgs.protocol.account.v1.GameTimeRemainingInfo game_time_remaining_info = 1;
+  if (has_game_time_remaining_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->game_time_remaining_info(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse)
+}
+
+::google::protobuf::uint8* GetGameTimeRemainingInfoResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse)
+  // optional .bgs.protocol.account.v1.GameTimeRemainingInfo game_time_remaining_info = 1;
+  if (has_game_time_remaining_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->game_time_remaining_info(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse)
+  return target;
+}
+
+int GetGameTimeRemainingInfoResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.GameTimeRemainingInfo game_time_remaining_info = 1;
+    if (has_game_time_remaining_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_time_remaining_info());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetGameTimeRemainingInfoResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetGameTimeRemainingInfoResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetGameTimeRemainingInfoResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetGameTimeRemainingInfoResponse::MergeFrom(const GetGameTimeRemainingInfoResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_game_time_remaining_info()) {
+      mutable_game_time_remaining_info()->::bgs::protocol::account::v1::GameTimeRemainingInfo::MergeFrom(from.game_time_remaining_info());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetGameTimeRemainingInfoResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetGameTimeRemainingInfoResponse::CopyFrom(const GetGameTimeRemainingInfoResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetGameTimeRemainingInfoResponse::IsInitialized() const {
+
+  return true;
+}
+
+void GetGameTimeRemainingInfoResponse::Swap(GetGameTimeRemainingInfoResponse* other) {
+  if (other != this) {
+    std::swap(game_time_remaining_info_, other->game_time_remaining_info_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetGameTimeRemainingInfoResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetGameTimeRemainingInfoResponse_descriptor_;
+  metadata.reflection = GetGameTimeRemainingInfoResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetCAISInfoRequest::kEntityIdFieldNumber;
+#endif  // !_MSC_VER
+
+GetCAISInfoRequest::GetCAISInfoRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetCAISInfoRequest)
+}
+
+void GetCAISInfoRequest::InitAsDefaultInstance() {
+  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+GetCAISInfoRequest::GetCAISInfoRequest(const GetCAISInfoRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetCAISInfoRequest)
+}
+
+void GetCAISInfoRequest::SharedCtor() {
+  _cached_size_ = 0;
+  entity_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetCAISInfoRequest::~GetCAISInfoRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetCAISInfoRequest)
+  SharedDtor();
+}
+
+void GetCAISInfoRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete entity_id_;
+  }
+}
+
+void GetCAISInfoRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetCAISInfoRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetCAISInfoRequest_descriptor_;
+}
+
+const GetCAISInfoRequest& GetCAISInfoRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetCAISInfoRequest* GetCAISInfoRequest::default_instance_ = NULL;
+
+GetCAISInfoRequest* GetCAISInfoRequest::New() const {
+  return new GetCAISInfoRequest;
+}
+
+void GetCAISInfoRequest::Clear() {
+  if (has_entity_id()) {
+    if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetCAISInfoRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetCAISInfoRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId entity_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetCAISInfoRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetCAISInfoRequest)
+  return false;
+#undef DO_
+}
+
+void GetCAISInfoRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetCAISInfoRequest)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->entity_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetCAISInfoRequest)
+}
+
+::google::protobuf::uint8* GetCAISInfoRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetCAISInfoRequest)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->entity_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetCAISInfoRequest)
+  return target;
+}
+
+int GetCAISInfoRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId entity_id = 1;
+    if (has_entity_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetCAISInfoRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetCAISInfoRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetCAISInfoRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetCAISInfoRequest::MergeFrom(const GetCAISInfoRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_entity_id()) {
+      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetCAISInfoRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetCAISInfoRequest::CopyFrom(const GetCAISInfoRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetCAISInfoRequest::IsInitialized() const {
+
+  if (has_entity_id()) {
+    if (!this->entity_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetCAISInfoRequest::Swap(GetCAISInfoRequest* other) {
+  if (other != this) {
+    std::swap(entity_id_, other->entity_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetCAISInfoRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetCAISInfoRequest_descriptor_;
+  metadata.reflection = GetCAISInfoRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetCAISInfoResponse::kCaisInfoFieldNumber;
+#endif  // !_MSC_VER
+
+GetCAISInfoResponse::GetCAISInfoResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetCAISInfoResponse)
+}
+
+void GetCAISInfoResponse::InitAsDefaultInstance() {
+  cais_info_ = const_cast< ::bgs::protocol::account::v1::CAIS*>(&::bgs::protocol::account::v1::CAIS::default_instance());
+}
+
+GetCAISInfoResponse::GetCAISInfoResponse(const GetCAISInfoResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetCAISInfoResponse)
+}
+
+void GetCAISInfoResponse::SharedCtor() {
+  _cached_size_ = 0;
+  cais_info_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetCAISInfoResponse::~GetCAISInfoResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetCAISInfoResponse)
+  SharedDtor();
+}
+
+void GetCAISInfoResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete cais_info_;
+  }
+}
+
+void GetCAISInfoResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetCAISInfoResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetCAISInfoResponse_descriptor_;
+}
+
+const GetCAISInfoResponse& GetCAISInfoResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetCAISInfoResponse* GetCAISInfoResponse::default_instance_ = NULL;
+
+GetCAISInfoResponse* GetCAISInfoResponse::New() const {
+  return new GetCAISInfoResponse;
+}
+
+void GetCAISInfoResponse::Clear() {
+  if (has_cais_info()) {
+    if (cais_info_ != NULL) cais_info_->::bgs::protocol::account::v1::CAIS::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetCAISInfoResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetCAISInfoResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.CAIS cais_info = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_cais_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetCAISInfoResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetCAISInfoResponse)
+  return false;
+#undef DO_
+}
+
+void GetCAISInfoResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetCAISInfoResponse)
+  // optional .bgs.protocol.account.v1.CAIS cais_info = 1;
+  if (has_cais_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->cais_info(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetCAISInfoResponse)
+}
+
+::google::protobuf::uint8* GetCAISInfoResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetCAISInfoResponse)
+  // optional .bgs.protocol.account.v1.CAIS cais_info = 1;
+  if (has_cais_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->cais_info(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetCAISInfoResponse)
+  return target;
+}
+
+int GetCAISInfoResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.CAIS cais_info = 1;
+    if (has_cais_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->cais_info());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetCAISInfoResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetCAISInfoResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetCAISInfoResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetCAISInfoResponse::MergeFrom(const GetCAISInfoResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_cais_info()) {
+      mutable_cais_info()->::bgs::protocol::account::v1::CAIS::MergeFrom(from.cais_info());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetCAISInfoResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetCAISInfoResponse::CopyFrom(const GetCAISInfoResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetCAISInfoResponse::IsInitialized() const {
+
+  return true;
+}
+
+void GetCAISInfoResponse::Swap(GetCAISInfoResponse* other) {
+  if (other != this) {
+    std::swap(cais_info_, other->cais_info_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetCAISInfoResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetCAISInfoResponse_descriptor_;
+  metadata.reflection = GetCAISInfoResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ForwardCacheExpireRequest::kEntityIdFieldNumber;
+#endif  // !_MSC_VER
+
+ForwardCacheExpireRequest::ForwardCacheExpireRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.ForwardCacheExpireRequest)
+}
+
+void ForwardCacheExpireRequest::InitAsDefaultInstance() {
+  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+ForwardCacheExpireRequest::ForwardCacheExpireRequest(const ForwardCacheExpireRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.ForwardCacheExpireRequest)
+}
+
+void ForwardCacheExpireRequest::SharedCtor() {
+  _cached_size_ = 0;
+  entity_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ForwardCacheExpireRequest::~ForwardCacheExpireRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.ForwardCacheExpireRequest)
+  SharedDtor();
+}
+
+void ForwardCacheExpireRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete entity_id_;
+  }
+}
+
+void ForwardCacheExpireRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ForwardCacheExpireRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ForwardCacheExpireRequest_descriptor_;
+}
+
+const ForwardCacheExpireRequest& ForwardCacheExpireRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ForwardCacheExpireRequest* ForwardCacheExpireRequest::default_instance_ = NULL;
+
+ForwardCacheExpireRequest* ForwardCacheExpireRequest::New() const {
+  return new ForwardCacheExpireRequest;
+}
+
+void ForwardCacheExpireRequest::Clear() {
+  if (has_entity_id()) {
+    if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ForwardCacheExpireRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.ForwardCacheExpireRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId entity_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.ForwardCacheExpireRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.ForwardCacheExpireRequest)
+  return false;
+#undef DO_
+}
+
+void ForwardCacheExpireRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.ForwardCacheExpireRequest)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->entity_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.ForwardCacheExpireRequest)
+}
+
+::google::protobuf::uint8* ForwardCacheExpireRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.ForwardCacheExpireRequest)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->entity_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.ForwardCacheExpireRequest)
+  return target;
+}
+
+int ForwardCacheExpireRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId entity_id = 1;
+    if (has_entity_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ForwardCacheExpireRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ForwardCacheExpireRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ForwardCacheExpireRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ForwardCacheExpireRequest::MergeFrom(const ForwardCacheExpireRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_entity_id()) {
+      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ForwardCacheExpireRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ForwardCacheExpireRequest::CopyFrom(const ForwardCacheExpireRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ForwardCacheExpireRequest::IsInitialized() const {
+
+  if (has_entity_id()) {
+    if (!this->entity_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ForwardCacheExpireRequest::Swap(ForwardCacheExpireRequest* other) {
+  if (other != this) {
+    std::swap(entity_id_, other->entity_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ForwardCacheExpireRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ForwardCacheExpireRequest_descriptor_;
+  metadata.reflection = ForwardCacheExpireRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetAuthorizedDataRequest::kEntityIdFieldNumber;
+const int GetAuthorizedDataRequest::kTagFieldNumber;
+const int GetAuthorizedDataRequest::kPrivilegedNetworkFieldNumber;
+#endif  // !_MSC_VER
+
+GetAuthorizedDataRequest::GetAuthorizedDataRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetAuthorizedDataRequest)
+}
+
+void GetAuthorizedDataRequest::InitAsDefaultInstance() {
+  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+GetAuthorizedDataRequest::GetAuthorizedDataRequest(const GetAuthorizedDataRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetAuthorizedDataRequest)
+}
+
+void GetAuthorizedDataRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  entity_id_ = NULL;
+  privileged_network_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetAuthorizedDataRequest::~GetAuthorizedDataRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetAuthorizedDataRequest)
+  SharedDtor();
+}
+
+void GetAuthorizedDataRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete entity_id_;
+  }
+}
+
+void GetAuthorizedDataRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetAuthorizedDataRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetAuthorizedDataRequest_descriptor_;
+}
+
+const GetAuthorizedDataRequest& GetAuthorizedDataRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetAuthorizedDataRequest* GetAuthorizedDataRequest::default_instance_ = NULL;
+
+GetAuthorizedDataRequest* GetAuthorizedDataRequest::New() const {
+  return new GetAuthorizedDataRequest;
+}
+
+void GetAuthorizedDataRequest::Clear() {
+  if (_has_bits_[0 / 32] & 5) {
+    if (has_entity_id()) {
+      if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+    }
+    privileged_network_ = false;
+  }
+  tag_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetAuthorizedDataRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetAuthorizedDataRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId entity_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_tag;
+        break;
+      }
+
+      // repeated string tag = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_tag:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_tag()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->tag(this->tag_size() - 1).data(),
+            this->tag(this->tag_size() - 1).length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "tag");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_tag;
+        if (input->ExpectTag(24)) goto parse_privileged_network;
+        break;
+      }
+
+      // optional bool privileged_network = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_privileged_network:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &privileged_network_)));
+          set_has_privileged_network();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetAuthorizedDataRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetAuthorizedDataRequest)
+  return false;
+#undef DO_
+}
+
+void GetAuthorizedDataRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetAuthorizedDataRequest)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->entity_id(), output);
+  }
+
+  // repeated string tag = 2;
+  for (int i = 0; i < this->tag_size(); i++) {
+  ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+    this->tag(i).data(), this->tag(i).length(),
+    ::google::protobuf::internal::WireFormat::SERIALIZE,
+    "tag");
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      2, this->tag(i), output);
+  }
+
+  // optional bool privileged_network = 3;
+  if (has_privileged_network()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->privileged_network(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetAuthorizedDataRequest)
+}
+
+::google::protobuf::uint8* GetAuthorizedDataRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetAuthorizedDataRequest)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->entity_id(), target);
+  }
+
+  // repeated string tag = 2;
+  for (int i = 0; i < this->tag_size(); i++) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->tag(i).data(), this->tag(i).length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "tag");
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteStringToArray(2, this->tag(i), target);
+  }
+
+  // optional bool privileged_network = 3;
+  if (has_privileged_network()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->privileged_network(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetAuthorizedDataRequest)
+  return target;
+}
+
+int GetAuthorizedDataRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId entity_id = 1;
+    if (has_entity_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+    }
+
+    // optional bool privileged_network = 3;
+    if (has_privileged_network()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated string tag = 2;
+  total_size += 1 * this->tag_size();
+  for (int i = 0; i < this->tag_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->tag(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetAuthorizedDataRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetAuthorizedDataRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetAuthorizedDataRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetAuthorizedDataRequest::MergeFrom(const GetAuthorizedDataRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  tag_.MergeFrom(from.tag_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_entity_id()) {
+      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
+    }
+    if (from.has_privileged_network()) {
+      set_privileged_network(from.privileged_network());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetAuthorizedDataRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetAuthorizedDataRequest::CopyFrom(const GetAuthorizedDataRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetAuthorizedDataRequest::IsInitialized() const {
+
+  if (has_entity_id()) {
+    if (!this->entity_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetAuthorizedDataRequest::Swap(GetAuthorizedDataRequest* other) {
+  if (other != this) {
+    std::swap(entity_id_, other->entity_id_);
+    tag_.Swap(&other->tag_);
+    std::swap(privileged_network_, other->privileged_network_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetAuthorizedDataRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetAuthorizedDataRequest_descriptor_;
+  metadata.reflection = GetAuthorizedDataRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetAuthorizedDataResponse::kDataFieldNumber;
+#endif  // !_MSC_VER
+
+GetAuthorizedDataResponse::GetAuthorizedDataResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GetAuthorizedDataResponse)
+}
+
+void GetAuthorizedDataResponse::InitAsDefaultInstance() {
+}
+
+GetAuthorizedDataResponse::GetAuthorizedDataResponse(const GetAuthorizedDataResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GetAuthorizedDataResponse)
+}
+
+void GetAuthorizedDataResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetAuthorizedDataResponse::~GetAuthorizedDataResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GetAuthorizedDataResponse)
+  SharedDtor();
+}
+
+void GetAuthorizedDataResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GetAuthorizedDataResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetAuthorizedDataResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetAuthorizedDataResponse_descriptor_;
+}
+
+const GetAuthorizedDataResponse& GetAuthorizedDataResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetAuthorizedDataResponse* GetAuthorizedDataResponse::default_instance_ = NULL;
+
+GetAuthorizedDataResponse* GetAuthorizedDataResponse::New() const {
+  return new GetAuthorizedDataResponse;
+}
+
+void GetAuthorizedDataResponse::Clear() {
+  data_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetAuthorizedDataResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GetAuthorizedDataResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.account.v1.AuthorizedData data = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_data:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_data()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_data;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GetAuthorizedDataResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GetAuthorizedDataResponse)
+  return false;
+#undef DO_
+}
+
+void GetAuthorizedDataResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GetAuthorizedDataResponse)
+  // repeated .bgs.protocol.account.v1.AuthorizedData data = 1;
+  for (int i = 0; i < this->data_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->data(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GetAuthorizedDataResponse)
+}
+
+::google::protobuf::uint8* GetAuthorizedDataResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GetAuthorizedDataResponse)
+  // repeated .bgs.protocol.account.v1.AuthorizedData data = 1;
+  for (int i = 0; i < this->data_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->data(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GetAuthorizedDataResponse)
+  return target;
+}
+
+int GetAuthorizedDataResponse::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.account.v1.AuthorizedData data = 1;
+  total_size += 1 * this->data_size();
+  for (int i = 0; i < this->data_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->data(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetAuthorizedDataResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetAuthorizedDataResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetAuthorizedDataResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetAuthorizedDataResponse::MergeFrom(const GetAuthorizedDataResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  data_.MergeFrom(from.data_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetAuthorizedDataResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetAuthorizedDataResponse::CopyFrom(const GetAuthorizedDataResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetAuthorizedDataResponse::IsInitialized() const {
+
+  return true;
+}
+
+void GetAuthorizedDataResponse::Swap(GetAuthorizedDataResponse* other) {
+  if (other != this) {
+    data_.Swap(&other->data_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetAuthorizedDataResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetAuthorizedDataResponse_descriptor_;
+  metadata.reflection = GetAuthorizedDataResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountStateNotification::kAccountStateFieldNumber;
+const int AccountStateNotification::kSubscriberIdFieldNumber;
+const int AccountStateNotification::kAccountTagsFieldNumber;
+const int AccountStateNotification::kSubscriptionCompletedFieldNumber;
+#endif  // !_MSC_VER
+
+AccountStateNotification::AccountStateNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountStateNotification)
+}
+
+void AccountStateNotification::InitAsDefaultInstance() {
+  account_state_ = const_cast< ::bgs::protocol::account::v1::AccountState*>(&::bgs::protocol::account::v1::AccountState::default_instance());
+  account_tags_ = const_cast< ::bgs::protocol::account::v1::AccountFieldTags*>(&::bgs::protocol::account::v1::AccountFieldTags::default_instance());
+}
+
+AccountStateNotification::AccountStateNotification(const AccountStateNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountStateNotification)
+}
+
+void AccountStateNotification::SharedCtor() {
+  _cached_size_ = 0;
+  account_state_ = NULL;
+  subscriber_id_ = GOOGLE_ULONGLONG(0);
+  account_tags_ = NULL;
+  subscription_completed_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountStateNotification::~AccountStateNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountStateNotification)
+  SharedDtor();
+}
+
+void AccountStateNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete account_state_;
+    delete account_tags_;
+  }
+}
+
+void AccountStateNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountStateNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountStateNotification_descriptor_;
+}
+
+const AccountStateNotification& AccountStateNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+AccountStateNotification* AccountStateNotification::default_instance_ = NULL;
+
+AccountStateNotification* AccountStateNotification::New() const {
+  return new AccountStateNotification;
+}
+
+void AccountStateNotification::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_account_state()) {
+      if (account_state_ != NULL) account_state_->::bgs::protocol::account::v1::AccountState::Clear();
+    }
+    subscriber_id_ = GOOGLE_ULONGLONG(0);
+    if (has_account_tags()) {
+      if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear();
+    }
+    subscription_completed_ = false;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountStateNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountStateNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountState account_state = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional uint64 subscriber_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_subscriber_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &subscriber_id_)));
+          set_has_subscriber_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_account_tags;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_account_tags:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_tags()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_subscription_completed;
+        break;
+      }
+
+      // optional bool subscription_completed = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_subscription_completed:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &subscription_completed_)));
+          set_has_subscription_completed();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountStateNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountStateNotification)
+  return false;
+#undef DO_
+}
+
+void AccountStateNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountStateNotification)
+  // optional .bgs.protocol.account.v1.AccountState account_state = 1;
+  if (has_account_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->account_state(), output);
+  }
+
+  // optional uint64 subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->subscriber_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
+  if (has_account_tags()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->account_tags(), output);
+  }
+
+  // optional bool subscription_completed = 4;
+  if (has_subscription_completed()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->subscription_completed(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountStateNotification)
+}
+
+::google::protobuf::uint8* AccountStateNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountStateNotification)
+  // optional .bgs.protocol.account.v1.AccountState account_state = 1;
+  if (has_account_state()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->account_state(), target);
+  }
+
+  // optional uint64 subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->subscriber_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
+  if (has_account_tags()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->account_tags(), target);
+  }
+
+  // optional bool subscription_completed = 4;
+  if (has_subscription_completed()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->subscription_completed(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountStateNotification)
+  return target;
+}
+
+int AccountStateNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountState account_state = 1;
+    if (has_account_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_state());
+    }
+
+    // optional uint64 subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->subscriber_id());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
+    if (has_account_tags()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_tags());
+    }
+
+    // optional bool subscription_completed = 4;
+    if (has_subscription_completed()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountStateNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountStateNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountStateNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountStateNotification::MergeFrom(const AccountStateNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account_state()) {
+      mutable_account_state()->::bgs::protocol::account::v1::AccountState::MergeFrom(from.account_state());
+    }
+    if (from.has_subscriber_id()) {
+      set_subscriber_id(from.subscriber_id());
+    }
+    if (from.has_account_tags()) {
+      mutable_account_tags()->::bgs::protocol::account::v1::AccountFieldTags::MergeFrom(from.account_tags());
+    }
+    if (from.has_subscription_completed()) {
+      set_subscription_completed(from.subscription_completed());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountStateNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountStateNotification::CopyFrom(const AccountStateNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountStateNotification::IsInitialized() const {
+
+  if (has_account_state()) {
+    if (!this->account_state().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AccountStateNotification::Swap(AccountStateNotification* other) {
+  if (other != this) {
+    std::swap(account_state_, other->account_state_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(account_tags_, other->account_tags_);
+    std::swap(subscription_completed_, other->subscription_completed_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountStateNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountStateNotification_descriptor_;
+  metadata.reflection = AccountStateNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameAccountStateNotification::kGameAccountStateFieldNumber;
+const int GameAccountStateNotification::kSubscriberIdFieldNumber;
+const int GameAccountStateNotification::kGameAccountTagsFieldNumber;
+const int GameAccountStateNotification::kSubscriptionCompletedFieldNumber;
+#endif  // !_MSC_VER
+
+GameAccountStateNotification::GameAccountStateNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountStateNotification)
+}
+
+void GameAccountStateNotification::InitAsDefaultInstance() {
+  game_account_state_ = const_cast< ::bgs::protocol::account::v1::GameAccountState*>(&::bgs::protocol::account::v1::GameAccountState::default_instance());
+  game_account_tags_ = const_cast< ::bgs::protocol::account::v1::GameAccountFieldTags*>(&::bgs::protocol::account::v1::GameAccountFieldTags::default_instance());
+}
+
+GameAccountStateNotification::GameAccountStateNotification(const GameAccountStateNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountStateNotification)
+}
+
+void GameAccountStateNotification::SharedCtor() {
+  _cached_size_ = 0;
+  game_account_state_ = NULL;
+  subscriber_id_ = GOOGLE_ULONGLONG(0);
+  game_account_tags_ = NULL;
+  subscription_completed_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameAccountStateNotification::~GameAccountStateNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountStateNotification)
+  SharedDtor();
+}
+
+void GameAccountStateNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete game_account_state_;
+    delete game_account_tags_;
+  }
+}
+
+void GameAccountStateNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameAccountStateNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameAccountStateNotification_descriptor_;
+}
+
+const GameAccountStateNotification& GameAccountStateNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GameAccountStateNotification* GameAccountStateNotification::default_instance_ = NULL;
+
+GameAccountStateNotification* GameAccountStateNotification::New() const {
+  return new GameAccountStateNotification;
+}
+
+void GameAccountStateNotification::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_game_account_state()) {
+      if (game_account_state_ != NULL) game_account_state_->::bgs::protocol::account::v1::GameAccountState::Clear();
+    }
+    subscriber_id_ = GOOGLE_ULONGLONG(0);
+    if (has_game_account_tags()) {
+      if (game_account_tags_ != NULL) game_account_tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear();
+    }
+    subscription_completed_ = false;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameAccountStateNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountStateNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional uint64 subscriber_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_subscriber_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &subscriber_id_)));
+          set_has_subscriber_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_game_account_tags;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_game_account_tags:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_tags()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_subscription_completed;
+        break;
+      }
+
+      // optional bool subscription_completed = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_subscription_completed:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &subscription_completed_)));
+          set_has_subscription_completed();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameAccountStateNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountStateNotification)
+  return false;
+#undef DO_
+}
+
+void GameAccountStateNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountStateNotification)
+  // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1;
+  if (has_game_account_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->game_account_state(), output);
+  }
+
+  // optional uint64 subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->subscriber_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 3;
+  if (has_game_account_tags()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->game_account_tags(), output);
+  }
+
+  // optional bool subscription_completed = 4;
+  if (has_subscription_completed()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->subscription_completed(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountStateNotification)
+}
+
+::google::protobuf::uint8* GameAccountStateNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountStateNotification)
+  // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1;
+  if (has_game_account_state()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->game_account_state(), target);
+  }
+
+  // optional uint64 subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->subscriber_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 3;
+  if (has_game_account_tags()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->game_account_tags(), target);
+  }
+
+  // optional bool subscription_completed = 4;
+  if (has_subscription_completed()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->subscription_completed(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountStateNotification)
+  return target;
+}
+
+int GameAccountStateNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1;
+    if (has_game_account_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_state());
+    }
+
+    // optional uint64 subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->subscriber_id());
+    }
+
+    // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 3;
+    if (has_game_account_tags()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_tags());
+    }
+
+    // optional bool subscription_completed = 4;
+    if (has_subscription_completed()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameAccountStateNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameAccountStateNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountStateNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameAccountStateNotification::MergeFrom(const GameAccountStateNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_game_account_state()) {
+      mutable_game_account_state()->::bgs::protocol::account::v1::GameAccountState::MergeFrom(from.game_account_state());
+    }
+    if (from.has_subscriber_id()) {
+      set_subscriber_id(from.subscriber_id());
+    }
+    if (from.has_game_account_tags()) {
+      mutable_game_account_tags()->::bgs::protocol::account::v1::GameAccountFieldTags::MergeFrom(from.game_account_tags());
+    }
+    if (from.has_subscription_completed()) {
+      set_subscription_completed(from.subscription_completed());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameAccountStateNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameAccountStateNotification::CopyFrom(const GameAccountStateNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameAccountStateNotification::IsInitialized() const {
+
+  if (has_game_account_state()) {
+    if (!this->game_account_state().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GameAccountStateNotification::Swap(GameAccountStateNotification* other) {
+  if (other != this) {
+    std::swap(game_account_state_, other->game_account_state_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(game_account_tags_, other->game_account_tags_);
+    std::swap(subscription_completed_, other->subscription_completed_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameAccountStateNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameAccountStateNotification_descriptor_;
+  metadata.reflection = GameAccountStateNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameAccountNotification::kGameAccountsFieldNumber;
+const int GameAccountNotification::kSubscriberIdFieldNumber;
+const int GameAccountNotification::kAccountTagsFieldNumber;
+#endif  // !_MSC_VER
+
+GameAccountNotification::GameAccountNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountNotification)
+}
+
+void GameAccountNotification::InitAsDefaultInstance() {
+  account_tags_ = const_cast< ::bgs::protocol::account::v1::AccountFieldTags*>(&::bgs::protocol::account::v1::AccountFieldTags::default_instance());
+}
+
+GameAccountNotification::GameAccountNotification(const GameAccountNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountNotification)
+}
+
+void GameAccountNotification::SharedCtor() {
+  _cached_size_ = 0;
+  subscriber_id_ = GOOGLE_ULONGLONG(0);
+  account_tags_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameAccountNotification::~GameAccountNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountNotification)
+  SharedDtor();
+}
+
+void GameAccountNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete account_tags_;
+  }
+}
+
+void GameAccountNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameAccountNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameAccountNotification_descriptor_;
+}
+
+const GameAccountNotification& GameAccountNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GameAccountNotification* GameAccountNotification::default_instance_ = NULL;
+
+GameAccountNotification* GameAccountNotification::New() const {
+  return new GameAccountNotification;
+}
+
+void GameAccountNotification::Clear() {
+  if (_has_bits_[0 / 32] & 6) {
+    subscriber_id_ = GOOGLE_ULONGLONG(0);
+    if (has_account_tags()) {
+      if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear();
+    }
+  }
+  game_accounts_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameAccountNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_game_accounts:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_game_accounts()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_game_accounts;
+        if (input->ExpectTag(16)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional uint64 subscriber_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_subscriber_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &subscriber_id_)));
+          set_has_subscriber_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_account_tags;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_account_tags:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_tags()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameAccountNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountNotification)
+  return false;
+#undef DO_
+}
+
+void GameAccountNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountNotification)
+  // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 1;
+  for (int i = 0; i < this->game_accounts_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->game_accounts(i), output);
+  }
+
+  // optional uint64 subscriber_id = 2;
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->subscriber_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
+  if (has_account_tags()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->account_tags(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountNotification)
+}
+
+::google::protobuf::uint8* GameAccountNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountNotification)
+  // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 1;
+  for (int i = 0; i < this->game_accounts_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->game_accounts(i), target);
+  }
+
+  // optional uint64 subscriber_id = 2;
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->subscriber_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
+  if (has_account_tags()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->account_tags(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountNotification)
+  return target;
+}
+
+int GameAccountNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional uint64 subscriber_id = 2;
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->subscriber_id());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
+    if (has_account_tags()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_tags());
+    }
+
+  }
+  // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 1;
+  total_size += 1 * this->game_accounts_size();
+  for (int i = 0; i < this->game_accounts_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->game_accounts(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameAccountNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameAccountNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameAccountNotification::MergeFrom(const GameAccountNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  game_accounts_.MergeFrom(from.game_accounts_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_subscriber_id()) {
+      set_subscriber_id(from.subscriber_id());
+    }
+    if (from.has_account_tags()) {
+      mutable_account_tags()->::bgs::protocol::account::v1::AccountFieldTags::MergeFrom(from.account_tags());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameAccountNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameAccountNotification::CopyFrom(const GameAccountNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameAccountNotification::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->game_accounts())) return false;
+  return true;
+}
+
+void GameAccountNotification::Swap(GameAccountNotification* other) {
+  if (other != this) {
+    game_accounts_.Swap(&other->game_accounts_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(account_tags_, other->account_tags_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameAccountNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameAccountNotification_descriptor_;
+  metadata.reflection = GameAccountNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameAccountSessionNotification::kGameAccountFieldNumber;
+const int GameAccountSessionNotification::kSessionInfoFieldNumber;
+#endif  // !_MSC_VER
+
+GameAccountSessionNotification::GameAccountSessionNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountSessionNotification)
+}
+
+void GameAccountSessionNotification::InitAsDefaultInstance() {
+  game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance());
+  session_info_ = const_cast< ::bgs::protocol::account::v1::GameSessionUpdateInfo*>(&::bgs::protocol::account::v1::GameSessionUpdateInfo::default_instance());
+}
+
+GameAccountSessionNotification::GameAccountSessionNotification(const GameAccountSessionNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountSessionNotification)
+}
+
+void GameAccountSessionNotification::SharedCtor() {
+  _cached_size_ = 0;
+  game_account_ = NULL;
+  session_info_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameAccountSessionNotification::~GameAccountSessionNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountSessionNotification)
+  SharedDtor();
+}
+
+void GameAccountSessionNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete game_account_;
+    delete session_info_;
+  }
+}
+
+void GameAccountSessionNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameAccountSessionNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameAccountSessionNotification_descriptor_;
+}
+
+const GameAccountSessionNotification& GameAccountSessionNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GameAccountSessionNotification* GameAccountSessionNotification::default_instance_ = NULL;
+
+GameAccountSessionNotification* GameAccountSessionNotification::New() const {
+  return new GameAccountSessionNotification;
+}
+
+void GameAccountSessionNotification::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_game_account()) {
+      if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
+    }
+    if (has_session_info()) {
+      if (session_info_ != NULL) session_info_->::bgs::protocol::account::v1::GameSessionUpdateInfo::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameAccountSessionNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountSessionNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_session_info;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.GameSessionUpdateInfo session_info = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_session_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_session_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameAccountSessionNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountSessionNotification)
+  return false;
+#undef DO_
+}
+
+void GameAccountSessionNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountSessionNotification)
+  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+  if (has_game_account()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->game_account(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.GameSessionUpdateInfo session_info = 2;
+  if (has_session_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->session_info(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountSessionNotification)
+}
+
+::google::protobuf::uint8* GameAccountSessionNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountSessionNotification)
+  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+  if (has_game_account()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->game_account(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.GameSessionUpdateInfo session_info = 2;
+  if (has_session_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->session_info(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountSessionNotification)
+  return target;
+}
+
+int GameAccountSessionNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+    if (has_game_account()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account());
+    }
+
+    // optional .bgs.protocol.account.v1.GameSessionUpdateInfo session_info = 2;
+    if (has_session_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->session_info());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameAccountSessionNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameAccountSessionNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountSessionNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameAccountSessionNotification::MergeFrom(const GameAccountSessionNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_game_account()) {
+      mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account());
+    }
+    if (from.has_session_info()) {
+      mutable_session_info()->::bgs::protocol::account::v1::GameSessionUpdateInfo::MergeFrom(from.session_info());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameAccountSessionNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameAccountSessionNotification::CopyFrom(const GameAccountSessionNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameAccountSessionNotification::IsInitialized() const {
+
+  if (has_game_account()) {
+    if (!this->game_account().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GameAccountSessionNotification::Swap(GameAccountSessionNotification* other) {
+  if (other != this) {
+    std::swap(game_account_, other->game_account_);
+    std::swap(session_info_, other->session_info_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameAccountSessionNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameAccountSessionNotification_descriptor_;
+  metadata.reflection = GameAccountSessionNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* AccountService::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountService_descriptor_;
+}
+
+void AccountService::GetGameAccount(::bgs::protocol::account::v1::GameAccountHandle const* request, std::function<void(::bgs::protocol::account::v1::GameAccountBlob const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetGameAccount(bgs.protocol.account.v1.GameAccountHandle{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 12, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::account::v1::GameAccountBlob response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AccountService::GetAccount(::bgs::protocol::account::v1::GetAccountRequest const* request, std::function<void(::bgs::protocol::account::v1::GetAccountResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetAccount(bgs.protocol.account.v1.GetAccountRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 13, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::account::v1::GetAccountResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AccountService::CreateGameAccount(::bgs::protocol::account::v1::CreateGameAccountRequest const* request, std::function<void(::bgs::protocol::account::v1::GameAccountHandle const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.CreateGameAccount(bgs.protocol.account.v1.CreateGameAccountRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 14, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::account::v1::GameAccountHandle response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AccountService::IsIgrAddress(::bgs::protocol::account::v1::IsIgrAddressRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.IsIgrAddress(bgs.protocol.account.v1.IsIgrAddressRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 15, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AccountService::CacheExpire(::bgs::protocol::account::v1::CacheExpireRequest const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.CacheExpire(bgs.protocol.account.v1.CacheExpireRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 20, request);
+}
+
+void AccountService::CredentialUpdate(::bgs::protocol::account::v1::CredentialUpdateRequest const* request, std::function<void(::bgs::protocol::account::v1::CredentialUpdateResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.CredentialUpdate(bgs.protocol.account.v1.CredentialUpdateRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 21, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::account::v1::CredentialUpdateResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AccountService::Subscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, std::function<void(::bgs::protocol::account::v1::SubscriptionUpdateResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.Subscribe(bgs.protocol.account.v1.SubscriptionUpdateRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 25, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::account::v1::SubscriptionUpdateResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AccountService::Unsubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.Unsubscribe(bgs.protocol.account.v1.SubscriptionUpdateRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 26, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AccountService::GetAccountState(::bgs::protocol::account::v1::GetAccountStateRequest const* request, std::function<void(::bgs::protocol::account::v1::GetAccountStateResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetAccountState(bgs.protocol.account.v1.GetAccountStateRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 30, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::account::v1::GetAccountStateResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AccountService::GetGameAccountState(::bgs::protocol::account::v1::GetGameAccountStateRequest const* request, std::function<void(::bgs::protocol::account::v1::GetGameAccountStateResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetGameAccountState(bgs.protocol.account.v1.GetGameAccountStateRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 31, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::account::v1::GetGameAccountStateResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AccountService::GetLicenses(::bgs::protocol::account::v1::GetLicensesRequest const* request, std::function<void(::bgs::protocol::account::v1::GetLicensesResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetLicenses(bgs.protocol.account.v1.GetLicensesRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 32, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::account::v1::GetLicensesResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AccountService::GetGameTimeRemainingInfo(::bgs::protocol::account::v1::GetGameTimeRemainingInfoRequest const* request, std::function<void(::bgs::protocol::account::v1::GetGameTimeRemainingInfoResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetGameTimeRemainingInfo(bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 33, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::account::v1::GetGameTimeRemainingInfoResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AccountService::GetGameSessionInfo(::bgs::protocol::account::v1::GetGameSessionInfoRequest const* request, std::function<void(::bgs::protocol::account::v1::GetGameSessionInfoResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetGameSessionInfo(bgs.protocol.account.v1.GetGameSessionInfoRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 34, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::account::v1::GetGameSessionInfoResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AccountService::GetCAISInfo(::bgs::protocol::account::v1::GetCAISInfoRequest const* request, std::function<void(::bgs::protocol::account::v1::GetCAISInfoResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetCAISInfo(bgs.protocol.account.v1.GetCAISInfoRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 35, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::account::v1::GetCAISInfoResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AccountService::ForwardCacheExpire(::bgs::protocol::account::v1::ForwardCacheExpireRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.ForwardCacheExpire(bgs.protocol.account.v1.ForwardCacheExpireRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 36, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AccountService::GetAuthorizedData(::bgs::protocol::account::v1::GetAuthorizedDataRequest const* request, std::function<void(::bgs::protocol::account::v1::GetAuthorizedDataResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GetAuthorizedData(bgs.protocol.account.v1.GetAuthorizedDataRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 37, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::account::v1::GetAuthorizedDataResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AccountService::AccountFlagUpdate(::bgs::protocol::account::v1::AccountFlagUpdateRequest const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.AccountFlagUpdate(bgs.protocol.account.v1.AccountFlagUpdateRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 38, request);
+}
+
+void AccountService::GameAccountFlagUpdate(::bgs::protocol::account::v1::GameAccountFlagUpdateRequest const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountService.GameAccountFlagUpdate(bgs.protocol.account.v1.GameAccountFlagUpdateRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 39, request);
+}
+
+void AccountService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 12: {
+      ::bgs::protocol::account::v1::GameAccountHandle request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetGameAccount server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 12, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::account::v1::GameAccountBlob response;
+      uint32 status = HandleGetGameAccount(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetGameAccount(bgs.protocol.account.v1.GameAccountHandle{ %s }) returned bgs.protocol.account.v1.GameAccountBlob{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 12, token, &response);
+      else
+        SendResponse(service_hash_, 12, token, status);
+      break;
+    }
+    case 13: {
+      ::bgs::protocol::account::v1::GetAccountRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetAccount server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 13, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::account::v1::GetAccountResponse response;
+      uint32 status = HandleGetAccount(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetAccount(bgs.protocol.account.v1.GetAccountRequest{ %s }) returned bgs.protocol.account.v1.GetAccountResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 13, token, &response);
+      else
+        SendResponse(service_hash_, 13, token, status);
+      break;
+    }
+    case 14: {
+      ::bgs::protocol::account::v1::CreateGameAccountRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.CreateGameAccount server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 14, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::account::v1::GameAccountHandle response;
+      uint32 status = HandleCreateGameAccount(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.CreateGameAccount(bgs.protocol.account.v1.CreateGameAccountRequest{ %s }) returned bgs.protocol.account.v1.GameAccountHandle{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 14, token, &response);
+      else
+        SendResponse(service_hash_, 14, token, status);
+      break;
+    }
+    case 15: {
+      ::bgs::protocol::account::v1::IsIgrAddressRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.IsIgrAddress server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 15, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleIsIgrAddress(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.IsIgrAddress(bgs.protocol.account.v1.IsIgrAddressRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 15, token, &response);
+      else
+        SendResponse(service_hash_, 15, token, status);
+      break;
+    }
+    case 20: {
+      ::bgs::protocol::account::v1::CacheExpireRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.CacheExpire server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 20, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleCacheExpire(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.CacheExpire(bgs.protocol.account.v1.CacheExpireRequest{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 20, token, status);
+      break;
+    }
+    case 21: {
+      ::bgs::protocol::account::v1::CredentialUpdateRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.CredentialUpdate server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 21, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::account::v1::CredentialUpdateResponse response;
+      uint32 status = HandleCredentialUpdate(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.CredentialUpdate(bgs.protocol.account.v1.CredentialUpdateRequest{ %s }) returned bgs.protocol.account.v1.CredentialUpdateResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 21, token, &response);
+      else
+        SendResponse(service_hash_, 21, token, status);
+      break;
+    }
+    case 25: {
+      ::bgs::protocol::account::v1::SubscriptionUpdateRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.Subscribe server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 25, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::account::v1::SubscriptionUpdateResponse response;
+      uint32 status = HandleSubscribe(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.Subscribe(bgs.protocol.account.v1.SubscriptionUpdateRequest{ %s }) returned bgs.protocol.account.v1.SubscriptionUpdateResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 25, token, &response);
+      else
+        SendResponse(service_hash_, 25, token, status);
+      break;
+    }
+    case 26: {
+      ::bgs::protocol::account::v1::SubscriptionUpdateRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.Unsubscribe server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 26, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleUnsubscribe(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.Unsubscribe(bgs.protocol.account.v1.SubscriptionUpdateRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 26, token, &response);
+      else
+        SendResponse(service_hash_, 26, token, status);
+      break;
+    }
+    case 30: {
+      ::bgs::protocol::account::v1::GetAccountStateRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetAccountState server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 30, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::account::v1::GetAccountStateResponse response;
+      uint32 status = HandleGetAccountState(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetAccountState(bgs.protocol.account.v1.GetAccountStateRequest{ %s }) returned bgs.protocol.account.v1.GetAccountStateResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 30, token, &response);
+      else
+        SendResponse(service_hash_, 30, token, status);
+      break;
+    }
+    case 31: {
+      ::bgs::protocol::account::v1::GetGameAccountStateRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetGameAccountState server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 31, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::account::v1::GetGameAccountStateResponse response;
+      uint32 status = HandleGetGameAccountState(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetGameAccountState(bgs.protocol.account.v1.GetGameAccountStateRequest{ %s }) returned bgs.protocol.account.v1.GetGameAccountStateResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 31, token, &response);
+      else
+        SendResponse(service_hash_, 31, token, status);
+      break;
+    }
+    case 32: {
+      ::bgs::protocol::account::v1::GetLicensesRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetLicenses server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 32, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::account::v1::GetLicensesResponse response;
+      uint32 status = HandleGetLicenses(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetLicenses(bgs.protocol.account.v1.GetLicensesRequest{ %s }) returned bgs.protocol.account.v1.GetLicensesResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 32, token, &response);
+      else
+        SendResponse(service_hash_, 32, token, status);
+      break;
+    }
+    case 33: {
+      ::bgs::protocol::account::v1::GetGameTimeRemainingInfoRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetGameTimeRemainingInfo server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 33, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::account::v1::GetGameTimeRemainingInfoResponse response;
+      uint32 status = HandleGetGameTimeRemainingInfo(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetGameTimeRemainingInfo(bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest{ %s }) returned bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 33, token, &response);
+      else
+        SendResponse(service_hash_, 33, token, status);
+      break;
+    }
+    case 34: {
+      ::bgs::protocol::account::v1::GetGameSessionInfoRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetGameSessionInfo server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 34, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::account::v1::GetGameSessionInfoResponse response;
+      uint32 status = HandleGetGameSessionInfo(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetGameSessionInfo(bgs.protocol.account.v1.GetGameSessionInfoRequest{ %s }) returned bgs.protocol.account.v1.GetGameSessionInfoResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 34, token, &response);
+      else
+        SendResponse(service_hash_, 34, token, status);
+      break;
+    }
+    case 35: {
+      ::bgs::protocol::account::v1::GetCAISInfoRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetCAISInfo server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 35, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::account::v1::GetCAISInfoResponse response;
+      uint32 status = HandleGetCAISInfo(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetCAISInfo(bgs.protocol.account.v1.GetCAISInfoRequest{ %s }) returned bgs.protocol.account.v1.GetCAISInfoResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 35, token, &response);
+      else
+        SendResponse(service_hash_, 35, token, status);
+      break;
+    }
+    case 36: {
+      ::bgs::protocol::account::v1::ForwardCacheExpireRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.ForwardCacheExpire server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 36, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleForwardCacheExpire(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.ForwardCacheExpire(bgs.protocol.account.v1.ForwardCacheExpireRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 36, token, &response);
+      else
+        SendResponse(service_hash_, 36, token, status);
+      break;
+    }
+    case 37: {
+      ::bgs::protocol::account::v1::GetAuthorizedDataRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GetAuthorizedData server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 37, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::account::v1::GetAuthorizedDataResponse response;
+      uint32 status = HandleGetAuthorizedData(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GetAuthorizedData(bgs.protocol.account.v1.GetAuthorizedDataRequest{ %s }) returned bgs.protocol.account.v1.GetAuthorizedDataResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 37, token, &response);
+      else
+        SendResponse(service_hash_, 37, token, status);
+      break;
+    }
+    case 38: {
+      ::bgs::protocol::account::v1::AccountFlagUpdateRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.AccountFlagUpdate server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 38, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleAccountFlagUpdate(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.AccountFlagUpdate(bgs.protocol.account.v1.AccountFlagUpdateRequest{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 38, token, status);
+      break;
+    }
+    case 39: {
+      ::bgs::protocol::account::v1::GameAccountFlagUpdateRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountService.GameAccountFlagUpdate server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 39, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleGameAccountFlagUpdate(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountService.GameAccountFlagUpdate(bgs.protocol.account.v1.GameAccountFlagUpdateRequest{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 39, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 AccountService::HandleGetGameAccount(::bgs::protocol::account::v1::GameAccountHandle const* request, ::bgs::protocol::account::v1::GameAccountBlob* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetGameAccount({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleGetAccount(::bgs::protocol::account::v1::GetAccountRequest const* request, ::bgs::protocol::account::v1::GetAccountResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetAccount({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleCreateGameAccount(::bgs::protocol::account::v1::CreateGameAccountRequest const* request, ::bgs::protocol::account::v1::GameAccountHandle* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.CreateGameAccount({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleIsIgrAddress(::bgs::protocol::account::v1::IsIgrAddressRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.IsIgrAddress({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleCacheExpire(::bgs::protocol::account::v1::CacheExpireRequest const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.CacheExpire({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleCredentialUpdate(::bgs::protocol::account::v1::CredentialUpdateRequest const* request, ::bgs::protocol::account::v1::CredentialUpdateResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.CredentialUpdate({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleSubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, ::bgs::protocol::account::v1::SubscriptionUpdateResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.Subscribe({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleUnsubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.Unsubscribe({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleGetAccountState(::bgs::protocol::account::v1::GetAccountStateRequest const* request, ::bgs::protocol::account::v1::GetAccountStateResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetAccountState({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleGetGameAccountState(::bgs::protocol::account::v1::GetGameAccountStateRequest const* request, ::bgs::protocol::account::v1::GetGameAccountStateResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetGameAccountState({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleGetLicenses(::bgs::protocol::account::v1::GetLicensesRequest const* request, ::bgs::protocol::account::v1::GetLicensesResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetLicenses({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleGetGameTimeRemainingInfo(::bgs::protocol::account::v1::GetGameTimeRemainingInfoRequest const* request, ::bgs::protocol::account::v1::GetGameTimeRemainingInfoResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetGameTimeRemainingInfo({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleGetGameSessionInfo(::bgs::protocol::account::v1::GetGameSessionInfoRequest const* request, ::bgs::protocol::account::v1::GetGameSessionInfoResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetGameSessionInfo({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleGetCAISInfo(::bgs::protocol::account::v1::GetCAISInfoRequest const* request, ::bgs::protocol::account::v1::GetCAISInfoResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetCAISInfo({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleForwardCacheExpire(::bgs::protocol::account::v1::ForwardCacheExpireRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.ForwardCacheExpire({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleGetAuthorizedData(::bgs::protocol::account::v1::GetAuthorizedDataRequest const* request, ::bgs::protocol::account::v1::GetAuthorizedDataResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GetAuthorizedData({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleAccountFlagUpdate(::bgs::protocol::account::v1::AccountFlagUpdateRequest const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.AccountFlagUpdate({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountService::HandleGameAccountFlagUpdate(::bgs::protocol::account::v1::GameAccountFlagUpdateRequest const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountService.GameAccountFlagUpdate({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* AccountListener::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountListener_descriptor_;
+}
+
+void AccountListener::OnAccountStateUpdated(::bgs::protocol::account::v1::AccountStateNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountListener.OnAccountStateUpdated(bgs.protocol.account.v1.AccountStateNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request);
+}
+
+void AccountListener::OnGameAccountStateUpdated(::bgs::protocol::account::v1::GameAccountStateNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountListener.OnGameAccountStateUpdated(bgs.protocol.account.v1.GameAccountStateNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 2, request);
+}
+
+void AccountListener::OnGameAccountsUpdated(::bgs::protocol::account::v1::GameAccountNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountListener.OnGameAccountsUpdated(bgs.protocol.account.v1.GameAccountNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 3, request);
+}
+
+void AccountListener::OnGameSessionUpdated(::bgs::protocol::account::v1::GameAccountSessionNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AccountListener.OnGameSessionUpdated(bgs.protocol.account.v1.GameAccountSessionNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 4, request);
+}
+
+void AccountListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::account::v1::AccountStateNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountListener.OnAccountStateUpdated server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnAccountStateUpdated(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountListener.OnAccountStateUpdated(bgs.protocol.account.v1.AccountStateNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    case 2: {
+      ::bgs::protocol::account::v1::GameAccountStateNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountListener.OnGameAccountStateUpdated server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnGameAccountStateUpdated(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountListener.OnGameAccountStateUpdated(bgs.protocol.account.v1.GameAccountStateNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 2, token, status);
+      break;
+    }
+    case 3: {
+      ::bgs::protocol::account::v1::GameAccountNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountListener.OnGameAccountsUpdated server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnGameAccountsUpdated(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountListener.OnGameAccountsUpdated(bgs.protocol.account.v1.GameAccountNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 3, token, status);
+      break;
+    }
+    case 4: {
+      ::bgs::protocol::account::v1::GameAccountSessionNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AccountListener.OnGameSessionUpdated server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnGameSessionUpdated(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AccountListener.OnGameSessionUpdated(bgs.protocol.account.v1.GameAccountSessionNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 4, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 AccountListener::HandleOnAccountStateUpdated(::bgs::protocol::account::v1::AccountStateNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountListener.OnAccountStateUpdated({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountListener::HandleOnGameAccountStateUpdated(::bgs::protocol::account::v1::GameAccountStateNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountListener.OnGameAccountStateUpdated({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountListener::HandleOnGameAccountsUpdated(::bgs::protocol::account::v1::GameAccountNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountListener.OnGameAccountsUpdated({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AccountListener::HandleOnGameSessionUpdated(::bgs::protocol::account::v1::GameAccountSessionNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AccountListener.OnGameSessionUpdated({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace account
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/account_service.pb.h b/src/server/proto/Client/account_service.pb.h
new file mode 100644
index 00000000000..fb65de7145b
--- /dev/null
+++ b/src/server/proto/Client/account_service.pb.h
@@ -0,0 +1,6583 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: account_service.proto
+
+#ifndef PROTOBUF_account_5fservice_2eproto__INCLUDED
+#define PROTOBUF_account_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 "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 account {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+void protobuf_AssignDesc_account_5fservice_2eproto();
+void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+class GetAccountRequest;
+class GetAccountResponse;
+class CreateGameAccountRequest;
+class CacheExpireRequest;
+class CredentialUpdateRequest;
+class CredentialUpdateResponse;
+class AccountFlagUpdateRequest;
+class GameAccountFlagUpdateRequest;
+class SubscriptionUpdateRequest;
+class SubscriptionUpdateResponse;
+class IsIgrAddressRequest;
+class AccountServiceRegion;
+class AccountServiceConfig;
+class GetAccountStateRequest;
+class GetAccountStateResponse;
+class GetGameAccountStateRequest;
+class GetGameAccountStateResponse;
+class GetLicensesRequest;
+class GetLicensesResponse;
+class GetGameSessionInfoRequest;
+class GetGameSessionInfoResponse;
+class GetGameTimeRemainingInfoRequest;
+class GetGameTimeRemainingInfoResponse;
+class GetCAISInfoRequest;
+class GetCAISInfoResponse;
+class ForwardCacheExpireRequest;
+class GetAuthorizedDataRequest;
+class GetAuthorizedDataResponse;
+class AccountStateNotification;
+class GameAccountStateNotification;
+class GameAccountNotification;
+class GameAccountSessionNotification;
+
+// ===================================================================
+
+class TC_SHARED_API GetAccountRequest : public ::google::protobuf::Message {
+ public:
+  GetAccountRequest();
+  virtual ~GetAccountRequest();
+
+  GetAccountRequest(const GetAccountRequest& from);
+
+  inline GetAccountRequest& operator=(const GetAccountRequest& 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 GetAccountRequest& default_instance();
+
+  void Swap(GetAccountRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetAccountRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetAccountRequest& from);
+  void MergeFrom(const GetAccountRequest& 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.account.v1.AccountReference ref = 1;
+  inline bool has_ref() const;
+  inline void clear_ref();
+  static const int kRefFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountReference& ref() const;
+  inline ::bgs::protocol::account::v1::AccountReference* mutable_ref();
+  inline ::bgs::protocol::account::v1::AccountReference* release_ref();
+  inline void set_allocated_ref(::bgs::protocol::account::v1::AccountReference* ref);
+
+  // optional bool fetch_all = 10 [default = false];
+  inline bool has_fetch_all() const;
+  inline void clear_fetch_all();
+  static const int kFetchAllFieldNumber = 10;
+  inline bool fetch_all() const;
+  inline void set_fetch_all(bool value);
+
+  // optional bool fetch_blob = 11 [default = false];
+  inline bool has_fetch_blob() const;
+  inline void clear_fetch_blob();
+  static const int kFetchBlobFieldNumber = 11;
+  inline bool fetch_blob() const;
+  inline void set_fetch_blob(bool value);
+
+  // optional bool fetch_id = 12 [default = false];
+  inline bool has_fetch_id() const;
+  inline void clear_fetch_id();
+  static const int kFetchIdFieldNumber = 12;
+  inline bool fetch_id() const;
+  inline void set_fetch_id(bool value);
+
+  // optional bool fetch_email = 13 [default = false];
+  inline bool has_fetch_email() const;
+  inline void clear_fetch_email();
+  static const int kFetchEmailFieldNumber = 13;
+  inline bool fetch_email() const;
+  inline void set_fetch_email(bool value);
+
+  // optional bool fetch_battle_tag = 14 [default = false];
+  inline bool has_fetch_battle_tag() const;
+  inline void clear_fetch_battle_tag();
+  static const int kFetchBattleTagFieldNumber = 14;
+  inline bool fetch_battle_tag() const;
+  inline void set_fetch_battle_tag(bool value);
+
+  // optional bool fetch_full_name = 15 [default = false];
+  inline bool has_fetch_full_name() const;
+  inline void clear_fetch_full_name();
+  static const int kFetchFullNameFieldNumber = 15;
+  inline bool fetch_full_name() const;
+  inline void set_fetch_full_name(bool value);
+
+  // optional bool fetch_links = 16 [default = false];
+  inline bool has_fetch_links() const;
+  inline void clear_fetch_links();
+  static const int kFetchLinksFieldNumber = 16;
+  inline bool fetch_links() const;
+  inline void set_fetch_links(bool value);
+
+  // optional bool fetch_parental_controls = 17 [default = false];
+  inline bool has_fetch_parental_controls() const;
+  inline void clear_fetch_parental_controls();
+  static const int kFetchParentalControlsFieldNumber = 17;
+  inline bool fetch_parental_controls() const;
+  inline void set_fetch_parental_controls(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountRequest)
+ private:
+  inline void set_has_ref();
+  inline void clear_has_ref();
+  inline void set_has_fetch_all();
+  inline void clear_has_fetch_all();
+  inline void set_has_fetch_blob();
+  inline void clear_has_fetch_blob();
+  inline void set_has_fetch_id();
+  inline void clear_has_fetch_id();
+  inline void set_has_fetch_email();
+  inline void clear_has_fetch_email();
+  inline void set_has_fetch_battle_tag();
+  inline void clear_has_fetch_battle_tag();
+  inline void set_has_fetch_full_name();
+  inline void clear_has_fetch_full_name();
+  inline void set_has_fetch_links();
+  inline void clear_has_fetch_links();
+  inline void set_has_fetch_parental_controls();
+  inline void clear_has_fetch_parental_controls();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountReference* ref_;
+  bool fetch_all_;
+  bool fetch_blob_;
+  bool fetch_id_;
+  bool fetch_email_;
+  bool fetch_battle_tag_;
+  bool fetch_full_name_;
+  bool fetch_links_;
+  bool fetch_parental_controls_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetAccountRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetAccountResponse : public ::google::protobuf::Message {
+ public:
+  GetAccountResponse();
+  virtual ~GetAccountResponse();
+
+  GetAccountResponse(const GetAccountResponse& from);
+
+  inline GetAccountResponse& operator=(const GetAccountResponse& 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 GetAccountResponse& default_instance();
+
+  void Swap(GetAccountResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetAccountResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetAccountResponse& from);
+  void MergeFrom(const GetAccountResponse& 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.account.v1.AccountBlob blob = 11;
+  inline bool has_blob() const;
+  inline void clear_blob();
+  static const int kBlobFieldNumber = 11;
+  inline const ::bgs::protocol::account::v1::AccountBlob& blob() const;
+  inline ::bgs::protocol::account::v1::AccountBlob* mutable_blob();
+  inline ::bgs::protocol::account::v1::AccountBlob* release_blob();
+  inline void set_allocated_blob(::bgs::protocol::account::v1::AccountBlob* blob);
+
+  // optional .bgs.protocol.account.v1.AccountId id = 12;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 12;
+  inline const ::bgs::protocol::account::v1::AccountId& id() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_id();
+  inline ::bgs::protocol::account::v1::AccountId* release_id();
+  inline void set_allocated_id(::bgs::protocol::account::v1::AccountId* id);
+
+  // repeated string email = 13;
+  inline int email_size() const;
+  inline void clear_email();
+  static const int kEmailFieldNumber = 13;
+  inline const ::std::string& email(int index) const;
+  inline ::std::string* mutable_email(int index);
+  inline void set_email(int index, const ::std::string& value);
+  inline void set_email(int index, const char* value);
+  inline void set_email(int index, const char* value, size_t size);
+  inline ::std::string* add_email();
+  inline void add_email(const ::std::string& value);
+  inline void add_email(const char* value);
+  inline void add_email(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& email() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_email();
+
+  // optional string battle_tag = 14;
+  inline bool has_battle_tag() const;
+  inline void clear_battle_tag();
+  static const int kBattleTagFieldNumber = 14;
+  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 full_name = 15;
+  inline bool has_full_name() const;
+  inline void clear_full_name();
+  static const int kFullNameFieldNumber = 15;
+  inline const ::std::string& full_name() const;
+  inline void set_full_name(const ::std::string& value);
+  inline void set_full_name(const char* value);
+  inline void set_full_name(const char* value, size_t size);
+  inline ::std::string* mutable_full_name();
+  inline ::std::string* release_full_name();
+  inline void set_allocated_full_name(::std::string* full_name);
+
+  // repeated .bgs.protocol.account.v1.GameAccountLink links = 16;
+  inline int links_size() const;
+  inline void clear_links();
+  static const int kLinksFieldNumber = 16;
+  inline const ::bgs::protocol::account::v1::GameAccountLink& links(int index) const;
+  inline ::bgs::protocol::account::v1::GameAccountLink* mutable_links(int index);
+  inline ::bgs::protocol::account::v1::GameAccountLink* add_links();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >&
+      links() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >*
+      mutable_links();
+
+  // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17;
+  inline bool has_parental_control_info() const;
+  inline void clear_parental_control_info();
+  static const int kParentalControlInfoFieldNumber = 17;
+  inline const ::bgs::protocol::account::v1::ParentalControlInfo& parental_control_info() const;
+  inline ::bgs::protocol::account::v1::ParentalControlInfo* mutable_parental_control_info();
+  inline ::bgs::protocol::account::v1::ParentalControlInfo* release_parental_control_info();
+  inline void set_allocated_parental_control_info(::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountResponse)
+ private:
+  inline void set_has_blob();
+  inline void clear_has_blob();
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_battle_tag();
+  inline void clear_has_battle_tag();
+  inline void set_has_full_name();
+  inline void clear_has_full_name();
+  inline void set_has_parental_control_info();
+  inline void clear_has_parental_control_info();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountBlob* blob_;
+  ::bgs::protocol::account::v1::AccountId* id_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> email_;
+  ::std::string* battle_tag_;
+  ::std::string* full_name_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink > links_;
+  ::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetAccountResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API CreateGameAccountRequest : public ::google::protobuf::Message {
+ public:
+  CreateGameAccountRequest();
+  virtual ~CreateGameAccountRequest();
+
+  CreateGameAccountRequest(const CreateGameAccountRequest& from);
+
+  inline CreateGameAccountRequest& operator=(const CreateGameAccountRequest& 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 CreateGameAccountRequest& default_instance();
+
+  void Swap(CreateGameAccountRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  CreateGameAccountRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CreateGameAccountRequest& from);
+  void MergeFrom(const CreateGameAccountRequest& 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.account.v1.AccountId account = 1;
+  inline bool has_account() const;
+  inline void clear_account();
+  static const int kAccountFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& account() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_account();
+  inline ::bgs::protocol::account::v1::AccountId* release_account();
+  inline void set_allocated_account(::bgs::protocol::account::v1::AccountId* account);
+
+  // optional uint32 region = 2;
+  inline bool has_region() const;
+  inline void clear_region();
+  static const int kRegionFieldNumber = 2;
+  inline ::google::protobuf::uint32 region() const;
+  inline void set_region(::google::protobuf::uint32 value);
+
+  // optional fixed32 program = 3;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 3;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // optional uint32 realm_permissions = 4 [default = 1];
+  inline bool has_realm_permissions() const;
+  inline void clear_realm_permissions();
+  static const int kRealmPermissionsFieldNumber = 4;
+  inline ::google::protobuf::uint32 realm_permissions() const;
+  inline void set_realm_permissions(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.CreateGameAccountRequest)
+ private:
+  inline void set_has_account();
+  inline void clear_has_account();
+  inline void set_has_region();
+  inline void clear_has_region();
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_realm_permissions();
+  inline void clear_has_realm_permissions();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* account_;
+  ::google::protobuf::uint32 region_;
+  ::google::protobuf::uint32 program_;
+  ::google::protobuf::uint32 realm_permissions_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static CreateGameAccountRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API CacheExpireRequest : public ::google::protobuf::Message {
+ public:
+  CacheExpireRequest();
+  virtual ~CacheExpireRequest();
+
+  CacheExpireRequest(const CacheExpireRequest& from);
+
+  inline CacheExpireRequest& operator=(const CacheExpireRequest& 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 CacheExpireRequest& default_instance();
+
+  void Swap(CacheExpireRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  CacheExpireRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CacheExpireRequest& from);
+  void MergeFrom(const CacheExpireRequest& 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.AccountId account = 1;
+  inline int account_size() const;
+  inline void clear_account();
+  static const int kAccountFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& account(int index) const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_account(int index);
+  inline ::bgs::protocol::account::v1::AccountId* add_account();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountId >&
+      account() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountId >*
+      mutable_account();
+
+  // repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
+  inline int game_account_size() const;
+  inline void clear_game_account();
+  static const int kGameAccountFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account(int index) const;
+  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account(int index);
+  inline ::bgs::protocol::account::v1::GameAccountHandle* add_game_account();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >&
+      game_account() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >*
+      mutable_game_account();
+
+  // repeated string email = 3;
+  inline int email_size() const;
+  inline void clear_email();
+  static const int kEmailFieldNumber = 3;
+  inline const ::std::string& email(int index) const;
+  inline ::std::string* mutable_email(int index);
+  inline void set_email(int index, const ::std::string& value);
+  inline void set_email(int index, const char* value);
+  inline void set_email(int index, const char* value, size_t size);
+  inline ::std::string* add_email();
+  inline void add_email(const ::std::string& value);
+  inline void add_email(const char* value);
+  inline void add_email(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& email() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_email();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.CacheExpireRequest)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountId > account_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle > game_account_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> email_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static CacheExpireRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API CredentialUpdateRequest : public ::google::protobuf::Message {
+ public:
+  CredentialUpdateRequest();
+  virtual ~CredentialUpdateRequest();
+
+  CredentialUpdateRequest(const CredentialUpdateRequest& from);
+
+  inline CredentialUpdateRequest& operator=(const CredentialUpdateRequest& 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 CredentialUpdateRequest& default_instance();
+
+  void Swap(CredentialUpdateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  CredentialUpdateRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CredentialUpdateRequest& from);
+  void MergeFrom(const CredentialUpdateRequest& 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.account.v1.AccountId account = 1;
+  inline bool has_account() const;
+  inline void clear_account();
+  static const int kAccountFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& account() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_account();
+  inline ::bgs::protocol::account::v1::AccountId* release_account();
+  inline void set_allocated_account(::bgs::protocol::account::v1::AccountId* account);
+
+  // repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2;
+  inline int old_credentials_size() const;
+  inline void clear_old_credentials();
+  static const int kOldCredentialsFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::AccountCredential& old_credentials(int index) const;
+  inline ::bgs::protocol::account::v1::AccountCredential* mutable_old_credentials(int index);
+  inline ::bgs::protocol::account::v1::AccountCredential* add_old_credentials();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >&
+      old_credentials() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >*
+      mutable_old_credentials();
+
+  // repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3;
+  inline int new_credentials_size() const;
+  inline void clear_new_credentials();
+  static const int kNewCredentialsFieldNumber = 3;
+  inline const ::bgs::protocol::account::v1::AccountCredential& new_credentials(int index) const;
+  inline ::bgs::protocol::account::v1::AccountCredential* mutable_new_credentials(int index);
+  inline ::bgs::protocol::account::v1::AccountCredential* add_new_credentials();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >&
+      new_credentials() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >*
+      mutable_new_credentials();
+
+  // optional uint32 region = 4;
+  inline bool has_region() const;
+  inline void clear_region();
+  static const int kRegionFieldNumber = 4;
+  inline ::google::protobuf::uint32 region() const;
+  inline void set_region(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.CredentialUpdateRequest)
+ private:
+  inline void set_has_account();
+  inline void clear_has_account();
+  inline void set_has_region();
+  inline void clear_has_region();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* account_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential > old_credentials_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential > new_credentials_;
+  ::google::protobuf::uint32 region_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static CredentialUpdateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API CredentialUpdateResponse : public ::google::protobuf::Message {
+ public:
+  CredentialUpdateResponse();
+  virtual ~CredentialUpdateResponse();
+
+  CredentialUpdateResponse(const CredentialUpdateResponse& from);
+
+  inline CredentialUpdateResponse& operator=(const CredentialUpdateResponse& 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 CredentialUpdateResponse& default_instance();
+
+  void Swap(CredentialUpdateResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  CredentialUpdateResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CredentialUpdateResponse& from);
+  void MergeFrom(const CredentialUpdateResponse& 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 -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.CredentialUpdateResponse)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static CredentialUpdateResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AccountFlagUpdateRequest : public ::google::protobuf::Message {
+ public:
+  AccountFlagUpdateRequest();
+  virtual ~AccountFlagUpdateRequest();
+
+  AccountFlagUpdateRequest(const AccountFlagUpdateRequest& from);
+
+  inline AccountFlagUpdateRequest& operator=(const AccountFlagUpdateRequest& 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 AccountFlagUpdateRequest& default_instance();
+
+  void Swap(AccountFlagUpdateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  AccountFlagUpdateRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AccountFlagUpdateRequest& from);
+  void MergeFrom(const AccountFlagUpdateRequest& 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.account.v1.AccountId account = 1;
+  inline bool has_account() const;
+  inline void clear_account();
+  static const int kAccountFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& account() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_account();
+  inline ::bgs::protocol::account::v1::AccountId* release_account();
+  inline void set_allocated_account(::bgs::protocol::account::v1::AccountId* account);
+
+  // optional uint32 region = 2;
+  inline bool has_region() const;
+  inline void clear_region();
+  static const int kRegionFieldNumber = 2;
+  inline ::google::protobuf::uint32 region() const;
+  inline void set_region(::google::protobuf::uint32 value);
+
+  // optional uint64 flag = 3;
+  inline bool has_flag() const;
+  inline void clear_flag();
+  static const int kFlagFieldNumber = 3;
+  inline ::google::protobuf::uint64 flag() const;
+  inline void set_flag(::google::protobuf::uint64 value);
+
+  // optional bool active = 4;
+  inline bool has_active() const;
+  inline void clear_active();
+  static const int kActiveFieldNumber = 4;
+  inline bool active() const;
+  inline void set_active(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountFlagUpdateRequest)
+ private:
+  inline void set_has_account();
+  inline void clear_has_account();
+  inline void set_has_region();
+  inline void clear_has_region();
+  inline void set_has_flag();
+  inline void clear_has_flag();
+  inline void set_has_active();
+  inline void clear_has_active();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* account_;
+  ::google::protobuf::uint64 flag_;
+  ::google::protobuf::uint32 region_;
+  bool active_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static AccountFlagUpdateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameAccountFlagUpdateRequest : public ::google::protobuf::Message {
+ public:
+  GameAccountFlagUpdateRequest();
+  virtual ~GameAccountFlagUpdateRequest();
+
+  GameAccountFlagUpdateRequest(const GameAccountFlagUpdateRequest& from);
+
+  inline GameAccountFlagUpdateRequest& operator=(const GameAccountFlagUpdateRequest& 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 GameAccountFlagUpdateRequest& default_instance();
+
+  void Swap(GameAccountFlagUpdateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GameAccountFlagUpdateRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameAccountFlagUpdateRequest& from);
+  void MergeFrom(const GameAccountFlagUpdateRequest& 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.account.v1.GameAccountHandle game_account = 1;
+  inline bool has_game_account() const;
+  inline void clear_game_account();
+  static const int kGameAccountFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const;
+  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account();
+  inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account();
+  inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account);
+
+  // optional uint64 flag = 2;
+  inline bool has_flag() const;
+  inline void clear_flag();
+  static const int kFlagFieldNumber = 2;
+  inline ::google::protobuf::uint64 flag() const;
+  inline void set_flag(::google::protobuf::uint64 value);
+
+  // optional bool active = 3;
+  inline bool has_active() const;
+  inline void clear_active();
+  static const int kActiveFieldNumber = 3;
+  inline bool active() const;
+  inline void set_active(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountFlagUpdateRequest)
+ private:
+  inline void set_has_game_account();
+  inline void clear_has_game_account();
+  inline void set_has_flag();
+  inline void clear_has_flag();
+  inline void set_has_active();
+  inline void clear_has_active();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
+  ::google::protobuf::uint64 flag_;
+  bool active_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameAccountFlagUpdateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API SubscriptionUpdateRequest : public ::google::protobuf::Message {
+ public:
+  SubscriptionUpdateRequest();
+  virtual ~SubscriptionUpdateRequest();
+
+  SubscriptionUpdateRequest(const SubscriptionUpdateRequest& from);
+
+  inline SubscriptionUpdateRequest& operator=(const SubscriptionUpdateRequest& 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 SubscriptionUpdateRequest& default_instance();
+
+  void Swap(SubscriptionUpdateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscriptionUpdateRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscriptionUpdateRequest& from);
+  void MergeFrom(const SubscriptionUpdateRequest& 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.SubscriberReference ref = 2;
+  inline int ref_size() const;
+  inline void clear_ref();
+  static const int kRefFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::SubscriberReference& ref(int index) const;
+  inline ::bgs::protocol::account::v1::SubscriberReference* mutable_ref(int index);
+  inline ::bgs::protocol::account::v1::SubscriberReference* add_ref();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >&
+      ref() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >*
+      mutable_ref();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.SubscriptionUpdateRequest)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference > ref_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscriptionUpdateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API SubscriptionUpdateResponse : public ::google::protobuf::Message {
+ public:
+  SubscriptionUpdateResponse();
+  virtual ~SubscriptionUpdateResponse();
+
+  SubscriptionUpdateResponse(const SubscriptionUpdateResponse& from);
+
+  inline SubscriptionUpdateResponse& operator=(const SubscriptionUpdateResponse& 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 SubscriptionUpdateResponse& default_instance();
+
+  void Swap(SubscriptionUpdateResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscriptionUpdateResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscriptionUpdateResponse& from);
+  void MergeFrom(const SubscriptionUpdateResponse& 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.SubscriberReference ref = 1;
+  inline int ref_size() const;
+  inline void clear_ref();
+  static const int kRefFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::SubscriberReference& ref(int index) const;
+  inline ::bgs::protocol::account::v1::SubscriberReference* mutable_ref(int index);
+  inline ::bgs::protocol::account::v1::SubscriberReference* add_ref();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >&
+      ref() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >*
+      mutable_ref();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.SubscriptionUpdateResponse)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference > ref_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscriptionUpdateResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API IsIgrAddressRequest : public ::google::protobuf::Message {
+ public:
+  IsIgrAddressRequest();
+  virtual ~IsIgrAddressRequest();
+
+  IsIgrAddressRequest(const IsIgrAddressRequest& from);
+
+  inline IsIgrAddressRequest& operator=(const IsIgrAddressRequest& 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 IsIgrAddressRequest& default_instance();
+
+  void Swap(IsIgrAddressRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  IsIgrAddressRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const IsIgrAddressRequest& from);
+  void MergeFrom(const IsIgrAddressRequest& 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 client_address = 1;
+  inline bool has_client_address() const;
+  inline void clear_client_address();
+  static const int kClientAddressFieldNumber = 1;
+  inline const ::std::string& client_address() const;
+  inline void set_client_address(const ::std::string& value);
+  inline void set_client_address(const char* value);
+  inline void set_client_address(const char* value, size_t size);
+  inline ::std::string* mutable_client_address();
+  inline ::std::string* release_client_address();
+  inline void set_allocated_client_address(::std::string* client_address);
+
+  // optional uint32 region = 2;
+  inline bool has_region() const;
+  inline void clear_region();
+  static const int kRegionFieldNumber = 2;
+  inline ::google::protobuf::uint32 region() const;
+  inline void set_region(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.IsIgrAddressRequest)
+ private:
+  inline void set_has_client_address();
+  inline void clear_has_client_address();
+  inline void set_has_region();
+  inline void clear_has_region();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* client_address_;
+  ::google::protobuf::uint32 region_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static IsIgrAddressRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AccountServiceRegion : public ::google::protobuf::Message {
+ public:
+  AccountServiceRegion();
+  virtual ~AccountServiceRegion();
+
+  AccountServiceRegion(const AccountServiceRegion& from);
+
+  inline AccountServiceRegion& operator=(const AccountServiceRegion& 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 AccountServiceRegion& default_instance();
+
+  void Swap(AccountServiceRegion* other);
+
+  // implements Message ----------------------------------------------
+
+  AccountServiceRegion* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AccountServiceRegion& from);
+  void MergeFrom(const AccountServiceRegion& 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 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // required string shard = 2;
+  inline bool has_shard() const;
+  inline void clear_shard();
+  static const int kShardFieldNumber = 2;
+  inline const ::std::string& shard() const;
+  inline void set_shard(const ::std::string& value);
+  inline void set_shard(const char* value);
+  inline void set_shard(const char* value, size_t size);
+  inline ::std::string* mutable_shard();
+  inline ::std::string* release_shard();
+  inline void set_allocated_shard(::std::string* shard);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountServiceRegion)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_shard();
+  inline void clear_has_shard();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* shard_;
+  ::google::protobuf::uint32 id_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static AccountServiceRegion* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AccountServiceConfig : public ::google::protobuf::Message {
+ public:
+  AccountServiceConfig();
+  virtual ~AccountServiceConfig();
+
+  AccountServiceConfig(const AccountServiceConfig& from);
+
+  inline AccountServiceConfig& operator=(const AccountServiceConfig& 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 AccountServiceConfig& default_instance();
+
+  void Swap(AccountServiceConfig* other);
+
+  // implements Message ----------------------------------------------
+
+  AccountServiceConfig* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AccountServiceConfig& from);
+  void MergeFrom(const AccountServiceConfig& 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.AccountServiceRegion region = 1;
+  inline int region_size() const;
+  inline void clear_region();
+  static const int kRegionFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountServiceRegion& region(int index) const;
+  inline ::bgs::protocol::account::v1::AccountServiceRegion* mutable_region(int index);
+  inline ::bgs::protocol::account::v1::AccountServiceRegion* add_region();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountServiceRegion >&
+      region() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountServiceRegion >*
+      mutable_region();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountServiceConfig)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountServiceRegion > region_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static AccountServiceConfig* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetAccountStateRequest : public ::google::protobuf::Message {
+ public:
+  GetAccountStateRequest();
+  virtual ~GetAccountStateRequest();
+
+  GetAccountStateRequest(const GetAccountStateRequest& from);
+
+  inline GetAccountStateRequest& operator=(const GetAccountStateRequest& 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 GetAccountStateRequest& default_instance();
+
+  void Swap(GetAccountStateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetAccountStateRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetAccountStateRequest& from);
+  void MergeFrom(const GetAccountStateRequest& 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.EntityId entity_id = 1;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // optional uint32 program = 2;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 2;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // optional uint32 region = 3;
+  inline bool has_region() const;
+  inline void clear_region();
+  static const int kRegionFieldNumber = 3;
+  inline ::google::protobuf::uint32 region() const;
+  inline void set_region(::google::protobuf::uint32 value);
+
+  // optional .bgs.protocol.account.v1.AccountFieldOptions options = 10;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 10;
+  inline const ::bgs::protocol::account::v1::AccountFieldOptions& options() const;
+  inline ::bgs::protocol::account::v1::AccountFieldOptions* mutable_options();
+  inline ::bgs::protocol::account::v1::AccountFieldOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::account::v1::AccountFieldOptions* options);
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags tags = 11;
+  inline bool has_tags() const;
+  inline void clear_tags();
+  static const int kTagsFieldNumber = 11;
+  inline const ::bgs::protocol::account::v1::AccountFieldTags& tags() const;
+  inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_tags();
+  inline ::bgs::protocol::account::v1::AccountFieldTags* release_tags();
+  inline void set_allocated_tags(::bgs::protocol::account::v1::AccountFieldTags* tags);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountStateRequest)
+ private:
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_region();
+  inline void clear_has_region();
+  inline void set_has_options();
+  inline void clear_has_options();
+  inline void set_has_tags();
+  inline void clear_has_tags();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* entity_id_;
+  ::google::protobuf::uint32 program_;
+  ::google::protobuf::uint32 region_;
+  ::bgs::protocol::account::v1::AccountFieldOptions* options_;
+  ::bgs::protocol::account::v1::AccountFieldTags* tags_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetAccountStateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetAccountStateResponse : public ::google::protobuf::Message {
+ public:
+  GetAccountStateResponse();
+  virtual ~GetAccountStateResponse();
+
+  GetAccountStateResponse(const GetAccountStateResponse& from);
+
+  inline GetAccountStateResponse& operator=(const GetAccountStateResponse& 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 GetAccountStateResponse& default_instance();
+
+  void Swap(GetAccountStateResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetAccountStateResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetAccountStateResponse& from);
+  void MergeFrom(const GetAccountStateResponse& 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.account.v1.AccountState state = 1;
+  inline bool has_state() const;
+  inline void clear_state();
+  static const int kStateFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountState& state() const;
+  inline ::bgs::protocol::account::v1::AccountState* mutable_state();
+  inline ::bgs::protocol::account::v1::AccountState* release_state();
+  inline void set_allocated_state(::bgs::protocol::account::v1::AccountState* state);
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags tags = 2;
+  inline bool has_tags() const;
+  inline void clear_tags();
+  static const int kTagsFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::AccountFieldTags& tags() const;
+  inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_tags();
+  inline ::bgs::protocol::account::v1::AccountFieldTags* release_tags();
+  inline void set_allocated_tags(::bgs::protocol::account::v1::AccountFieldTags* tags);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountStateResponse)
+ private:
+  inline void set_has_state();
+  inline void clear_has_state();
+  inline void set_has_tags();
+  inline void clear_has_tags();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountState* state_;
+  ::bgs::protocol::account::v1::AccountFieldTags* tags_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetAccountStateResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetGameAccountStateRequest : public ::google::protobuf::Message {
+ public:
+  GetGameAccountStateRequest();
+  virtual ~GetGameAccountStateRequest();
+
+  GetGameAccountStateRequest(const GetGameAccountStateRequest& from);
+
+  inline GetGameAccountStateRequest& operator=(const GetGameAccountStateRequest& 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 GetGameAccountStateRequest& default_instance();
+
+  void Swap(GetGameAccountStateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetGameAccountStateRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetGameAccountStateRequest& from);
+  void MergeFrom(const GetGameAccountStateRequest& 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.EntityId account_id = 1 [deprecated = true];
+  inline bool has_account_id() const PROTOBUF_DEPRECATED;
+  inline void clear_account_id() PROTOBUF_DEPRECATED;
+  static const int kAccountIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& account_id() const PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::EntityId* mutable_account_id() PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::EntityId* release_account_id() PROTOBUF_DEPRECATED;
+  inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id) PROTOBUF_DEPRECATED;
+
+  // 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);
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldOptions options = 10;
+  inline bool has_options() const;
+  inline void clear_options();
+  static const int kOptionsFieldNumber = 10;
+  inline const ::bgs::protocol::account::v1::GameAccountFieldOptions& options() const;
+  inline ::bgs::protocol::account::v1::GameAccountFieldOptions* mutable_options();
+  inline ::bgs::protocol::account::v1::GameAccountFieldOptions* release_options();
+  inline void set_allocated_options(::bgs::protocol::account::v1::GameAccountFieldOptions* options);
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 11;
+  inline bool has_tags() const;
+  inline void clear_tags();
+  static const int kTagsFieldNumber = 11;
+  inline const ::bgs::protocol::account::v1::GameAccountFieldTags& tags() const;
+  inline ::bgs::protocol::account::v1::GameAccountFieldTags* mutable_tags();
+  inline ::bgs::protocol::account::v1::GameAccountFieldTags* release_tags();
+  inline void set_allocated_tags(::bgs::protocol::account::v1::GameAccountFieldTags* tags);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameAccountStateRequest)
+ private:
+  inline void set_has_account_id();
+  inline void clear_has_account_id();
+  inline void set_has_game_account_id();
+  inline void clear_has_game_account_id();
+  inline void set_has_options();
+  inline void clear_has_options();
+  inline void set_has_tags();
+  inline void clear_has_tags();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* account_id_;
+  ::bgs::protocol::EntityId* game_account_id_;
+  ::bgs::protocol::account::v1::GameAccountFieldOptions* options_;
+  ::bgs::protocol::account::v1::GameAccountFieldTags* tags_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetGameAccountStateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetGameAccountStateResponse : public ::google::protobuf::Message {
+ public:
+  GetGameAccountStateResponse();
+  virtual ~GetGameAccountStateResponse();
+
+  GetGameAccountStateResponse(const GetGameAccountStateResponse& from);
+
+  inline GetGameAccountStateResponse& operator=(const GetGameAccountStateResponse& 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 GetGameAccountStateResponse& default_instance();
+
+  void Swap(GetGameAccountStateResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetGameAccountStateResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetGameAccountStateResponse& from);
+  void MergeFrom(const GetGameAccountStateResponse& 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.account.v1.GameAccountState state = 1;
+  inline bool has_state() const;
+  inline void clear_state();
+  static const int kStateFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::GameAccountState& state() const;
+  inline ::bgs::protocol::account::v1::GameAccountState* mutable_state();
+  inline ::bgs::protocol::account::v1::GameAccountState* release_state();
+  inline void set_allocated_state(::bgs::protocol::account::v1::GameAccountState* state);
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 2;
+  inline bool has_tags() const;
+  inline void clear_tags();
+  static const int kTagsFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::GameAccountFieldTags& tags() const;
+  inline ::bgs::protocol::account::v1::GameAccountFieldTags* mutable_tags();
+  inline ::bgs::protocol::account::v1::GameAccountFieldTags* release_tags();
+  inline void set_allocated_tags(::bgs::protocol::account::v1::GameAccountFieldTags* tags);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameAccountStateResponse)
+ private:
+  inline void set_has_state();
+  inline void clear_has_state();
+  inline void set_has_tags();
+  inline void clear_has_tags();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::GameAccountState* state_;
+  ::bgs::protocol::account::v1::GameAccountFieldTags* tags_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetGameAccountStateResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetLicensesRequest : public ::google::protobuf::Message {
+ public:
+  GetLicensesRequest();
+  virtual ~GetLicensesRequest();
+
+  GetLicensesRequest(const GetLicensesRequest& from);
+
+  inline GetLicensesRequest& operator=(const GetLicensesRequest& 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 GetLicensesRequest& default_instance();
+
+  void Swap(GetLicensesRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetLicensesRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetLicensesRequest& from);
+  void MergeFrom(const GetLicensesRequest& 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.EntityId target_id = 1;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& target_id() const;
+  inline ::bgs::protocol::EntityId* mutable_target_id();
+  inline ::bgs::protocol::EntityId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id);
+
+  // optional bool fetch_account_licenses = 2;
+  inline bool has_fetch_account_licenses() const;
+  inline void clear_fetch_account_licenses();
+  static const int kFetchAccountLicensesFieldNumber = 2;
+  inline bool fetch_account_licenses() const;
+  inline void set_fetch_account_licenses(bool value);
+
+  // optional bool fetch_game_account_licenses = 3;
+  inline bool has_fetch_game_account_licenses() const;
+  inline void clear_fetch_game_account_licenses();
+  static const int kFetchGameAccountLicensesFieldNumber = 3;
+  inline bool fetch_game_account_licenses() const;
+  inline void set_fetch_game_account_licenses(bool value);
+
+  // optional bool fetch_dynamic_account_licenses = 4;
+  inline bool has_fetch_dynamic_account_licenses() const;
+  inline void clear_fetch_dynamic_account_licenses();
+  static const int kFetchDynamicAccountLicensesFieldNumber = 4;
+  inline bool fetch_dynamic_account_licenses() const;
+  inline void set_fetch_dynamic_account_licenses(bool value);
+
+  // optional fixed32 program = 5;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 5;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // optional bool exclude_unknown_program = 6 [default = false];
+  inline bool has_exclude_unknown_program() const;
+  inline void clear_exclude_unknown_program();
+  static const int kExcludeUnknownProgramFieldNumber = 6;
+  inline bool exclude_unknown_program() const;
+  inline void set_exclude_unknown_program(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetLicensesRequest)
+ private:
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+  inline void set_has_fetch_account_licenses();
+  inline void clear_has_fetch_account_licenses();
+  inline void set_has_fetch_game_account_licenses();
+  inline void clear_has_fetch_game_account_licenses();
+  inline void set_has_fetch_dynamic_account_licenses();
+  inline void clear_has_fetch_dynamic_account_licenses();
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_exclude_unknown_program();
+  inline void clear_has_exclude_unknown_program();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* target_id_;
+  bool fetch_account_licenses_;
+  bool fetch_game_account_licenses_;
+  bool fetch_dynamic_account_licenses_;
+  bool exclude_unknown_program_;
+  ::google::protobuf::uint32 program_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetLicensesRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetLicensesResponse : public ::google::protobuf::Message {
+ public:
+  GetLicensesResponse();
+  virtual ~GetLicensesResponse();
+
+  GetLicensesResponse(const GetLicensesResponse& from);
+
+  inline GetLicensesResponse& operator=(const GetLicensesResponse& 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 GetLicensesResponse& default_instance();
+
+  void Swap(GetLicensesResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetLicensesResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetLicensesResponse& from);
+  void MergeFrom(const GetLicensesResponse& 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();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetLicensesResponse)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense > licenses_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetLicensesResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetGameSessionInfoRequest : public ::google::protobuf::Message {
+ public:
+  GetGameSessionInfoRequest();
+  virtual ~GetGameSessionInfoRequest();
+
+  GetGameSessionInfoRequest(const GetGameSessionInfoRequest& from);
+
+  inline GetGameSessionInfoRequest& operator=(const GetGameSessionInfoRequest& 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 GetGameSessionInfoRequest& default_instance();
+
+  void Swap(GetGameSessionInfoRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetGameSessionInfoRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetGameSessionInfoRequest& from);
+  void MergeFrom(const GetGameSessionInfoRequest& 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.EntityId entity_id = 1;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameSessionInfoRequest)
+ private:
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* entity_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetGameSessionInfoRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetGameSessionInfoResponse : public ::google::protobuf::Message {
+ public:
+  GetGameSessionInfoResponse();
+  virtual ~GetGameSessionInfoResponse();
+
+  GetGameSessionInfoResponse(const GetGameSessionInfoResponse& from);
+
+  inline GetGameSessionInfoResponse& operator=(const GetGameSessionInfoResponse& 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 GetGameSessionInfoResponse& default_instance();
+
+  void Swap(GetGameSessionInfoResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetGameSessionInfoResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetGameSessionInfoResponse& from);
+  void MergeFrom(const GetGameSessionInfoResponse& 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.account.v1.GameSessionInfo session_info = 2;
+  inline bool has_session_info() const;
+  inline void clear_session_info();
+  static const int kSessionInfoFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::GameSessionInfo& session_info() const;
+  inline ::bgs::protocol::account::v1::GameSessionInfo* mutable_session_info();
+  inline ::bgs::protocol::account::v1::GameSessionInfo* release_session_info();
+  inline void set_allocated_session_info(::bgs::protocol::account::v1::GameSessionInfo* session_info);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameSessionInfoResponse)
+ private:
+  inline void set_has_session_info();
+  inline void clear_has_session_info();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::GameSessionInfo* session_info_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetGameSessionInfoResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetGameTimeRemainingInfoRequest : public ::google::protobuf::Message {
+ public:
+  GetGameTimeRemainingInfoRequest();
+  virtual ~GetGameTimeRemainingInfoRequest();
+
+  GetGameTimeRemainingInfoRequest(const GetGameTimeRemainingInfoRequest& from);
+
+  inline GetGameTimeRemainingInfoRequest& operator=(const GetGameTimeRemainingInfoRequest& 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 GetGameTimeRemainingInfoRequest& default_instance();
+
+  void Swap(GetGameTimeRemainingInfoRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetGameTimeRemainingInfoRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetGameTimeRemainingInfoRequest& from);
+  void MergeFrom(const GetGameTimeRemainingInfoRequest& 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.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);
+
+  // 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);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest)
+ private:
+  inline void set_has_game_account_id();
+  inline void clear_has_game_account_id();
+  inline void set_has_account_id();
+  inline void clear_has_account_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* game_account_id_;
+  ::bgs::protocol::EntityId* account_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetGameTimeRemainingInfoRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetGameTimeRemainingInfoResponse : public ::google::protobuf::Message {
+ public:
+  GetGameTimeRemainingInfoResponse();
+  virtual ~GetGameTimeRemainingInfoResponse();
+
+  GetGameTimeRemainingInfoResponse(const GetGameTimeRemainingInfoResponse& from);
+
+  inline GetGameTimeRemainingInfoResponse& operator=(const GetGameTimeRemainingInfoResponse& 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 GetGameTimeRemainingInfoResponse& default_instance();
+
+  void Swap(GetGameTimeRemainingInfoResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetGameTimeRemainingInfoResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetGameTimeRemainingInfoResponse& from);
+  void MergeFrom(const GetGameTimeRemainingInfoResponse& 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.account.v1.GameTimeRemainingInfo game_time_remaining_info = 1;
+  inline bool has_game_time_remaining_info() const;
+  inline void clear_game_time_remaining_info();
+  static const int kGameTimeRemainingInfoFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::GameTimeRemainingInfo& game_time_remaining_info() const;
+  inline ::bgs::protocol::account::v1::GameTimeRemainingInfo* mutable_game_time_remaining_info();
+  inline ::bgs::protocol::account::v1::GameTimeRemainingInfo* release_game_time_remaining_info();
+  inline void set_allocated_game_time_remaining_info(::bgs::protocol::account::v1::GameTimeRemainingInfo* game_time_remaining_info);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse)
+ private:
+  inline void set_has_game_time_remaining_info();
+  inline void clear_has_game_time_remaining_info();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::GameTimeRemainingInfo* game_time_remaining_info_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetGameTimeRemainingInfoResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetCAISInfoRequest : public ::google::protobuf::Message {
+ public:
+  GetCAISInfoRequest();
+  virtual ~GetCAISInfoRequest();
+
+  GetCAISInfoRequest(const GetCAISInfoRequest& from);
+
+  inline GetCAISInfoRequest& operator=(const GetCAISInfoRequest& 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 GetCAISInfoRequest& default_instance();
+
+  void Swap(GetCAISInfoRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetCAISInfoRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetCAISInfoRequest& from);
+  void MergeFrom(const GetCAISInfoRequest& 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.EntityId entity_id = 1;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetCAISInfoRequest)
+ private:
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* entity_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetCAISInfoRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetCAISInfoResponse : public ::google::protobuf::Message {
+ public:
+  GetCAISInfoResponse();
+  virtual ~GetCAISInfoResponse();
+
+  GetCAISInfoResponse(const GetCAISInfoResponse& from);
+
+  inline GetCAISInfoResponse& operator=(const GetCAISInfoResponse& 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 GetCAISInfoResponse& default_instance();
+
+  void Swap(GetCAISInfoResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetCAISInfoResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetCAISInfoResponse& from);
+  void MergeFrom(const GetCAISInfoResponse& 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.account.v1.CAIS cais_info = 1;
+  inline bool has_cais_info() const;
+  inline void clear_cais_info();
+  static const int kCaisInfoFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::CAIS& cais_info() const;
+  inline ::bgs::protocol::account::v1::CAIS* mutable_cais_info();
+  inline ::bgs::protocol::account::v1::CAIS* release_cais_info();
+  inline void set_allocated_cais_info(::bgs::protocol::account::v1::CAIS* cais_info);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetCAISInfoResponse)
+ private:
+  inline void set_has_cais_info();
+  inline void clear_has_cais_info();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::CAIS* cais_info_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetCAISInfoResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ForwardCacheExpireRequest : public ::google::protobuf::Message {
+ public:
+  ForwardCacheExpireRequest();
+  virtual ~ForwardCacheExpireRequest();
+
+  ForwardCacheExpireRequest(const ForwardCacheExpireRequest& from);
+
+  inline ForwardCacheExpireRequest& operator=(const ForwardCacheExpireRequest& 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 ForwardCacheExpireRequest& default_instance();
+
+  void Swap(ForwardCacheExpireRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ForwardCacheExpireRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ForwardCacheExpireRequest& from);
+  void MergeFrom(const ForwardCacheExpireRequest& 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.EntityId entity_id = 1;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.ForwardCacheExpireRequest)
+ private:
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* entity_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ForwardCacheExpireRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetAuthorizedDataRequest : public ::google::protobuf::Message {
+ public:
+  GetAuthorizedDataRequest();
+  virtual ~GetAuthorizedDataRequest();
+
+  GetAuthorizedDataRequest(const GetAuthorizedDataRequest& from);
+
+  inline GetAuthorizedDataRequest& operator=(const GetAuthorizedDataRequest& 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 GetAuthorizedDataRequest& default_instance();
+
+  void Swap(GetAuthorizedDataRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetAuthorizedDataRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetAuthorizedDataRequest& from);
+  void MergeFrom(const GetAuthorizedDataRequest& 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.EntityId entity_id = 1;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // repeated string tag = 2;
+  inline int tag_size() const;
+  inline void clear_tag();
+  static const int kTagFieldNumber = 2;
+  inline const ::std::string& tag(int index) const;
+  inline ::std::string* mutable_tag(int index);
+  inline void set_tag(int index, const ::std::string& value);
+  inline void set_tag(int index, const char* value);
+  inline void set_tag(int index, const char* value, size_t size);
+  inline ::std::string* add_tag();
+  inline void add_tag(const ::std::string& value);
+  inline void add_tag(const char* value);
+  inline void add_tag(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& tag() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_tag();
+
+  // optional bool privileged_network = 3;
+  inline bool has_privileged_network() const;
+  inline void clear_privileged_network();
+  static const int kPrivilegedNetworkFieldNumber = 3;
+  inline bool privileged_network() const;
+  inline void set_privileged_network(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAuthorizedDataRequest)
+ private:
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+  inline void set_has_privileged_network();
+  inline void clear_has_privileged_network();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* entity_id_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> tag_;
+  bool privileged_network_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetAuthorizedDataRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetAuthorizedDataResponse : public ::google::protobuf::Message {
+ public:
+  GetAuthorizedDataResponse();
+  virtual ~GetAuthorizedDataResponse();
+
+  GetAuthorizedDataResponse(const GetAuthorizedDataResponse& from);
+
+  inline GetAuthorizedDataResponse& operator=(const GetAuthorizedDataResponse& 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 GetAuthorizedDataResponse& default_instance();
+
+  void Swap(GetAuthorizedDataResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetAuthorizedDataResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetAuthorizedDataResponse& from);
+  void MergeFrom(const GetAuthorizedDataResponse& 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.AuthorizedData data = 1;
+  inline int data_size() const;
+  inline void clear_data();
+  static const int kDataFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AuthorizedData& data(int index) const;
+  inline ::bgs::protocol::account::v1::AuthorizedData* mutable_data(int index);
+  inline ::bgs::protocol::account::v1::AuthorizedData* add_data();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AuthorizedData >&
+      data() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AuthorizedData >*
+      mutable_data();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAuthorizedDataResponse)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AuthorizedData > data_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetAuthorizedDataResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AccountStateNotification : public ::google::protobuf::Message {
+ public:
+  AccountStateNotification();
+  virtual ~AccountStateNotification();
+
+  AccountStateNotification(const AccountStateNotification& from);
+
+  inline AccountStateNotification& operator=(const AccountStateNotification& 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 AccountStateNotification& default_instance();
+
+  void Swap(AccountStateNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  AccountStateNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AccountStateNotification& from);
+  void MergeFrom(const AccountStateNotification& 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.account.v1.AccountState account_state = 1;
+  inline bool has_account_state() const;
+  inline void clear_account_state();
+  static const int kAccountStateFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountState& account_state() const;
+  inline ::bgs::protocol::account::v1::AccountState* mutable_account_state();
+  inline ::bgs::protocol::account::v1::AccountState* release_account_state();
+  inline void set_allocated_account_state(::bgs::protocol::account::v1::AccountState* account_state);
+
+  // optional uint64 subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 subscriber_id() const;
+  inline void set_subscriber_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
+  inline bool has_account_tags() const;
+  inline void clear_account_tags();
+  static const int kAccountTagsFieldNumber = 3;
+  inline const ::bgs::protocol::account::v1::AccountFieldTags& account_tags() const;
+  inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_account_tags();
+  inline ::bgs::protocol::account::v1::AccountFieldTags* release_account_tags();
+  inline void set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags);
+
+  // optional bool subscription_completed = 4;
+  inline bool has_subscription_completed() const;
+  inline void clear_subscription_completed();
+  static const int kSubscriptionCompletedFieldNumber = 4;
+  inline bool subscription_completed() const;
+  inline void set_subscription_completed(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountStateNotification)
+ private:
+  inline void set_has_account_state();
+  inline void clear_has_account_state();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_account_tags();
+  inline void clear_has_account_tags();
+  inline void set_has_subscription_completed();
+  inline void clear_has_subscription_completed();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountState* account_state_;
+  ::google::protobuf::uint64 subscriber_id_;
+  ::bgs::protocol::account::v1::AccountFieldTags* account_tags_;
+  bool subscription_completed_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static AccountStateNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameAccountStateNotification : public ::google::protobuf::Message {
+ public:
+  GameAccountStateNotification();
+  virtual ~GameAccountStateNotification();
+
+  GameAccountStateNotification(const GameAccountStateNotification& from);
+
+  inline GameAccountStateNotification& operator=(const GameAccountStateNotification& 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 GameAccountStateNotification& default_instance();
+
+  void Swap(GameAccountStateNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  GameAccountStateNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameAccountStateNotification& from);
+  void MergeFrom(const GameAccountStateNotification& 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.account.v1.GameAccountState game_account_state = 1;
+  inline bool has_game_account_state() const;
+  inline void clear_game_account_state();
+  static const int kGameAccountStateFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::GameAccountState& game_account_state() const;
+  inline ::bgs::protocol::account::v1::GameAccountState* mutable_game_account_state();
+  inline ::bgs::protocol::account::v1::GameAccountState* release_game_account_state();
+  inline void set_allocated_game_account_state(::bgs::protocol::account::v1::GameAccountState* game_account_state);
+
+  // optional uint64 subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 subscriber_id() const;
+  inline void set_subscriber_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 3;
+  inline bool has_game_account_tags() const;
+  inline void clear_game_account_tags();
+  static const int kGameAccountTagsFieldNumber = 3;
+  inline const ::bgs::protocol::account::v1::GameAccountFieldTags& game_account_tags() const;
+  inline ::bgs::protocol::account::v1::GameAccountFieldTags* mutable_game_account_tags();
+  inline ::bgs::protocol::account::v1::GameAccountFieldTags* release_game_account_tags();
+  inline void set_allocated_game_account_tags(::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags);
+
+  // optional bool subscription_completed = 4;
+  inline bool has_subscription_completed() const;
+  inline void clear_subscription_completed();
+  static const int kSubscriptionCompletedFieldNumber = 4;
+  inline bool subscription_completed() const;
+  inline void set_subscription_completed(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountStateNotification)
+ private:
+  inline void set_has_game_account_state();
+  inline void clear_has_game_account_state();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_game_account_tags();
+  inline void clear_has_game_account_tags();
+  inline void set_has_subscription_completed();
+  inline void clear_has_subscription_completed();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::GameAccountState* game_account_state_;
+  ::google::protobuf::uint64 subscriber_id_;
+  ::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags_;
+  bool subscription_completed_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameAccountStateNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameAccountNotification : public ::google::protobuf::Message {
+ public:
+  GameAccountNotification();
+  virtual ~GameAccountNotification();
+
+  GameAccountNotification(const GameAccountNotification& from);
+
+  inline GameAccountNotification& operator=(const GameAccountNotification& 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 GameAccountNotification& default_instance();
+
+  void Swap(GameAccountNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  GameAccountNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameAccountNotification& from);
+  void MergeFrom(const GameAccountNotification& 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.GameAccountList game_accounts = 1;
+  inline int game_accounts_size() const;
+  inline void clear_game_accounts();
+  static const int kGameAccountsFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::GameAccountList& game_accounts(int index) const;
+  inline ::bgs::protocol::account::v1::GameAccountList* mutable_game_accounts(int index);
+  inline ::bgs::protocol::account::v1::GameAccountList* add_game_accounts();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >&
+      game_accounts() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >*
+      mutable_game_accounts();
+
+  // optional uint64 subscriber_id = 2;
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 subscriber_id() const;
+  inline void set_subscriber_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
+  inline bool has_account_tags() const;
+  inline void clear_account_tags();
+  static const int kAccountTagsFieldNumber = 3;
+  inline const ::bgs::protocol::account::v1::AccountFieldTags& account_tags() const;
+  inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_account_tags();
+  inline ::bgs::protocol::account::v1::AccountFieldTags* release_account_tags();
+  inline void set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountNotification)
+ private:
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+  inline void set_has_account_tags();
+  inline void clear_has_account_tags();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList > game_accounts_;
+  ::google::protobuf::uint64 subscriber_id_;
+  ::bgs::protocol::account::v1::AccountFieldTags* account_tags_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameAccountNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameAccountSessionNotification : public ::google::protobuf::Message {
+ public:
+  GameAccountSessionNotification();
+  virtual ~GameAccountSessionNotification();
+
+  GameAccountSessionNotification(const GameAccountSessionNotification& from);
+
+  inline GameAccountSessionNotification& operator=(const GameAccountSessionNotification& 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 GameAccountSessionNotification& default_instance();
+
+  void Swap(GameAccountSessionNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  GameAccountSessionNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameAccountSessionNotification& from);
+  void MergeFrom(const GameAccountSessionNotification& 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.account.v1.GameAccountHandle game_account = 1;
+  inline bool has_game_account() const;
+  inline void clear_game_account();
+  static const int kGameAccountFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const;
+  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account();
+  inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account();
+  inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account);
+
+  // optional .bgs.protocol.account.v1.GameSessionUpdateInfo session_info = 2;
+  inline bool has_session_info() const;
+  inline void clear_session_info();
+  static const int kSessionInfoFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::GameSessionUpdateInfo& session_info() const;
+  inline ::bgs::protocol::account::v1::GameSessionUpdateInfo* mutable_session_info();
+  inline ::bgs::protocol::account::v1::GameSessionUpdateInfo* release_session_info();
+  inline void set_allocated_session_info(::bgs::protocol::account::v1::GameSessionUpdateInfo* session_info);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountSessionNotification)
+ private:
+  inline void set_has_game_account();
+  inline void clear_has_game_account();
+  inline void set_has_session_info();
+  inline void clear_has_session_info();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
+  ::bgs::protocol::account::v1::GameSessionUpdateInfo* session_info_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5fservice_2eproto();
+  friend void protobuf_AssignDesc_account_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameAccountSessionNotification* default_instance_;
+};
+// ===================================================================
+
+class TC_SHARED_API AccountService : public ServiceBase
+{
+ public:
+
+  template<typename HashSelector>
+  explicit AccountService(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  typedef std::integral_constant<uint32, 0x62DA0891u> OriginalHash;
+  typedef std::integral_constant<uint32, 0x1E4DC42Fu> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void GetGameAccount(::bgs::protocol::account::v1::GameAccountHandle const* request, std::function<void(::bgs::protocol::account::v1::GameAccountBlob const*)> responseCallback);
+  void GetAccount(::bgs::protocol::account::v1::GetAccountRequest const* request, std::function<void(::bgs::protocol::account::v1::GetAccountResponse const*)> responseCallback);
+  void CreateGameAccount(::bgs::protocol::account::v1::CreateGameAccountRequest const* request, std::function<void(::bgs::protocol::account::v1::GameAccountHandle const*)> responseCallback);
+  void IsIgrAddress(::bgs::protocol::account::v1::IsIgrAddressRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void CacheExpire(::bgs::protocol::account::v1::CacheExpireRequest const* request);
+  void CredentialUpdate(::bgs::protocol::account::v1::CredentialUpdateRequest const* request, std::function<void(::bgs::protocol::account::v1::CredentialUpdateResponse const*)> responseCallback);
+  void Subscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, std::function<void(::bgs::protocol::account::v1::SubscriptionUpdateResponse const*)> responseCallback);
+  void Unsubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void GetAccountState(::bgs::protocol::account::v1::GetAccountStateRequest const* request, std::function<void(::bgs::protocol::account::v1::GetAccountStateResponse const*)> responseCallback);
+  void GetGameAccountState(::bgs::protocol::account::v1::GetGameAccountStateRequest const* request, std::function<void(::bgs::protocol::account::v1::GetGameAccountStateResponse const*)> responseCallback);
+  void GetLicenses(::bgs::protocol::account::v1::GetLicensesRequest const* request, std::function<void(::bgs::protocol::account::v1::GetLicensesResponse const*)> responseCallback);
+  void GetGameTimeRemainingInfo(::bgs::protocol::account::v1::GetGameTimeRemainingInfoRequest const* request, std::function<void(::bgs::protocol::account::v1::GetGameTimeRemainingInfoResponse const*)> responseCallback);
+  void GetGameSessionInfo(::bgs::protocol::account::v1::GetGameSessionInfoRequest const* request, std::function<void(::bgs::protocol::account::v1::GetGameSessionInfoResponse const*)> responseCallback);
+  void GetCAISInfo(::bgs::protocol::account::v1::GetCAISInfoRequest const* request, std::function<void(::bgs::protocol::account::v1::GetCAISInfoResponse const*)> responseCallback);
+  void ForwardCacheExpire(::bgs::protocol::account::v1::ForwardCacheExpireRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void GetAuthorizedData(::bgs::protocol::account::v1::GetAuthorizedDataRequest const* request, std::function<void(::bgs::protocol::account::v1::GetAuthorizedDataResponse const*)> responseCallback);
+  void AccountFlagUpdate(::bgs::protocol::account::v1::AccountFlagUpdateRequest const* request);
+  void GameAccountFlagUpdate(::bgs::protocol::account::v1::GameAccountFlagUpdateRequest const* request);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleGetGameAccount(::bgs::protocol::account::v1::GameAccountHandle const* request, ::bgs::protocol::account::v1::GameAccountBlob* response);
+  virtual uint32 HandleGetAccount(::bgs::protocol::account::v1::GetAccountRequest const* request, ::bgs::protocol::account::v1::GetAccountResponse* response);
+  virtual uint32 HandleCreateGameAccount(::bgs::protocol::account::v1::CreateGameAccountRequest const* request, ::bgs::protocol::account::v1::GameAccountHandle* response);
+  virtual uint32 HandleIsIgrAddress(::bgs::protocol::account::v1::IsIgrAddressRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleCacheExpire(::bgs::protocol::account::v1::CacheExpireRequest const* request);
+  virtual uint32 HandleCredentialUpdate(::bgs::protocol::account::v1::CredentialUpdateRequest const* request, ::bgs::protocol::account::v1::CredentialUpdateResponse* response);
+  virtual uint32 HandleSubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, ::bgs::protocol::account::v1::SubscriptionUpdateResponse* response);
+  virtual uint32 HandleUnsubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleGetAccountState(::bgs::protocol::account::v1::GetAccountStateRequest const* request, ::bgs::protocol::account::v1::GetAccountStateResponse* response);
+  virtual uint32 HandleGetGameAccountState(::bgs::protocol::account::v1::GetGameAccountStateRequest const* request, ::bgs::protocol::account::v1::GetGameAccountStateResponse* response);
+  virtual uint32 HandleGetLicenses(::bgs::protocol::account::v1::GetLicensesRequest const* request, ::bgs::protocol::account::v1::GetLicensesResponse* response);
+  virtual uint32 HandleGetGameTimeRemainingInfo(::bgs::protocol::account::v1::GetGameTimeRemainingInfoRequest const* request, ::bgs::protocol::account::v1::GetGameTimeRemainingInfoResponse* response);
+  virtual uint32 HandleGetGameSessionInfo(::bgs::protocol::account::v1::GetGameSessionInfoRequest const* request, ::bgs::protocol::account::v1::GetGameSessionInfoResponse* response);
+  virtual uint32 HandleGetCAISInfo(::bgs::protocol::account::v1::GetCAISInfoRequest const* request, ::bgs::protocol::account::v1::GetCAISInfoResponse* response);
+  virtual uint32 HandleForwardCacheExpire(::bgs::protocol::account::v1::ForwardCacheExpireRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleGetAuthorizedData(::bgs::protocol::account::v1::GetAuthorizedDataRequest const* request, ::bgs::protocol::account::v1::GetAuthorizedDataResponse* response);
+  virtual uint32 HandleAccountFlagUpdate(::bgs::protocol::account::v1::AccountFlagUpdateRequest const* request);
+  virtual uint32 HandleGameAccountFlagUpdate(::bgs::protocol::account::v1::GameAccountFlagUpdateRequest const* request);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(AccountService);
+};
+
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AccountListener : public ServiceBase
+{
+ public:
+
+  template<typename HashSelector>
+  explicit AccountListener(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  typedef std::integral_constant<uint32, 0x54DFDA17u> OriginalHash;
+  typedef std::integral_constant<uint32, 0x7807483Cu> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void OnAccountStateUpdated(::bgs::protocol::account::v1::AccountStateNotification const* request);
+  void OnGameAccountStateUpdated(::bgs::protocol::account::v1::GameAccountStateNotification const* request);
+  void OnGameAccountsUpdated(::bgs::protocol::account::v1::GameAccountNotification const* request);
+  void OnGameSessionUpdated(::bgs::protocol::account::v1::GameAccountSessionNotification const* request);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleOnAccountStateUpdated(::bgs::protocol::account::v1::AccountStateNotification const* request);
+  virtual uint32 HandleOnGameAccountStateUpdated(::bgs::protocol::account::v1::GameAccountStateNotification const* request);
+  virtual uint32 HandleOnGameAccountsUpdated(::bgs::protocol::account::v1::GameAccountNotification const* request);
+  virtual uint32 HandleOnGameSessionUpdated(::bgs::protocol::account::v1::GameAccountSessionNotification const* request);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(AccountListener);
+};
+
+// ===================================================================
+
+
+// ===================================================================
+
+// GetAccountRequest
+
+// optional .bgs.protocol.account.v1.AccountReference ref = 1;
+inline bool GetAccountRequest::has_ref() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetAccountRequest::set_has_ref() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetAccountRequest::clear_has_ref() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetAccountRequest::clear_ref() {
+  if (ref_ != NULL) ref_->::bgs::protocol::account::v1::AccountReference::Clear();
+  clear_has_ref();
+}
+inline const ::bgs::protocol::account::v1::AccountReference& GetAccountRequest::ref() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.ref)
+  return ref_ != NULL ? *ref_ : *default_instance_->ref_;
+}
+inline ::bgs::protocol::account::v1::AccountReference* GetAccountRequest::mutable_ref() {
+  set_has_ref();
+  if (ref_ == NULL) ref_ = new ::bgs::protocol::account::v1::AccountReference;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountRequest.ref)
+  return ref_;
+}
+inline ::bgs::protocol::account::v1::AccountReference* GetAccountRequest::release_ref() {
+  clear_has_ref();
+  ::bgs::protocol::account::v1::AccountReference* temp = ref_;
+  ref_ = NULL;
+  return temp;
+}
+inline void GetAccountRequest::set_allocated_ref(::bgs::protocol::account::v1::AccountReference* ref) {
+  delete ref_;
+  ref_ = ref;
+  if (ref) {
+    set_has_ref();
+  } else {
+    clear_has_ref();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountRequest.ref)
+}
+
+// optional bool fetch_all = 10 [default = false];
+inline bool GetAccountRequest::has_fetch_all() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetAccountRequest::set_has_fetch_all() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetAccountRequest::clear_has_fetch_all() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetAccountRequest::clear_fetch_all() {
+  fetch_all_ = false;
+  clear_has_fetch_all();
+}
+inline bool GetAccountRequest::fetch_all() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_all)
+  return fetch_all_;
+}
+inline void GetAccountRequest::set_fetch_all(bool value) {
+  set_has_fetch_all();
+  fetch_all_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_all)
+}
+
+// optional bool fetch_blob = 11 [default = false];
+inline bool GetAccountRequest::has_fetch_blob() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetAccountRequest::set_has_fetch_blob() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetAccountRequest::clear_has_fetch_blob() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetAccountRequest::clear_fetch_blob() {
+  fetch_blob_ = false;
+  clear_has_fetch_blob();
+}
+inline bool GetAccountRequest::fetch_blob() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_blob)
+  return fetch_blob_;
+}
+inline void GetAccountRequest::set_fetch_blob(bool value) {
+  set_has_fetch_blob();
+  fetch_blob_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_blob)
+}
+
+// optional bool fetch_id = 12 [default = false];
+inline bool GetAccountRequest::has_fetch_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GetAccountRequest::set_has_fetch_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GetAccountRequest::clear_has_fetch_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GetAccountRequest::clear_fetch_id() {
+  fetch_id_ = false;
+  clear_has_fetch_id();
+}
+inline bool GetAccountRequest::fetch_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_id)
+  return fetch_id_;
+}
+inline void GetAccountRequest::set_fetch_id(bool value) {
+  set_has_fetch_id();
+  fetch_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_id)
+}
+
+// optional bool fetch_email = 13 [default = false];
+inline bool GetAccountRequest::has_fetch_email() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void GetAccountRequest::set_has_fetch_email() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void GetAccountRequest::clear_has_fetch_email() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void GetAccountRequest::clear_fetch_email() {
+  fetch_email_ = false;
+  clear_has_fetch_email();
+}
+inline bool GetAccountRequest::fetch_email() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_email)
+  return fetch_email_;
+}
+inline void GetAccountRequest::set_fetch_email(bool value) {
+  set_has_fetch_email();
+  fetch_email_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_email)
+}
+
+// optional bool fetch_battle_tag = 14 [default = false];
+inline bool GetAccountRequest::has_fetch_battle_tag() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void GetAccountRequest::set_has_fetch_battle_tag() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void GetAccountRequest::clear_has_fetch_battle_tag() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void GetAccountRequest::clear_fetch_battle_tag() {
+  fetch_battle_tag_ = false;
+  clear_has_fetch_battle_tag();
+}
+inline bool GetAccountRequest::fetch_battle_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_battle_tag)
+  return fetch_battle_tag_;
+}
+inline void GetAccountRequest::set_fetch_battle_tag(bool value) {
+  set_has_fetch_battle_tag();
+  fetch_battle_tag_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_battle_tag)
+}
+
+// optional bool fetch_full_name = 15 [default = false];
+inline bool GetAccountRequest::has_fetch_full_name() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void GetAccountRequest::set_has_fetch_full_name() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void GetAccountRequest::clear_has_fetch_full_name() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void GetAccountRequest::clear_fetch_full_name() {
+  fetch_full_name_ = false;
+  clear_has_fetch_full_name();
+}
+inline bool GetAccountRequest::fetch_full_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_full_name)
+  return fetch_full_name_;
+}
+inline void GetAccountRequest::set_fetch_full_name(bool value) {
+  set_has_fetch_full_name();
+  fetch_full_name_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_full_name)
+}
+
+// optional bool fetch_links = 16 [default = false];
+inline bool GetAccountRequest::has_fetch_links() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void GetAccountRequest::set_has_fetch_links() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void GetAccountRequest::clear_has_fetch_links() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void GetAccountRequest::clear_fetch_links() {
+  fetch_links_ = false;
+  clear_has_fetch_links();
+}
+inline bool GetAccountRequest::fetch_links() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_links)
+  return fetch_links_;
+}
+inline void GetAccountRequest::set_fetch_links(bool value) {
+  set_has_fetch_links();
+  fetch_links_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_links)
+}
+
+// optional bool fetch_parental_controls = 17 [default = false];
+inline bool GetAccountRequest::has_fetch_parental_controls() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void GetAccountRequest::set_has_fetch_parental_controls() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void GetAccountRequest::clear_has_fetch_parental_controls() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void GetAccountRequest::clear_fetch_parental_controls() {
+  fetch_parental_controls_ = false;
+  clear_has_fetch_parental_controls();
+}
+inline bool GetAccountRequest::fetch_parental_controls() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountRequest.fetch_parental_controls)
+  return fetch_parental_controls_;
+}
+inline void GetAccountRequest::set_fetch_parental_controls(bool value) {
+  set_has_fetch_parental_controls();
+  fetch_parental_controls_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountRequest.fetch_parental_controls)
+}
+
+// -------------------------------------------------------------------
+
+// GetAccountResponse
+
+// optional .bgs.protocol.account.v1.AccountBlob blob = 11;
+inline bool GetAccountResponse::has_blob() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetAccountResponse::set_has_blob() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetAccountResponse::clear_has_blob() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetAccountResponse::clear_blob() {
+  if (blob_ != NULL) blob_->::bgs::protocol::account::v1::AccountBlob::Clear();
+  clear_has_blob();
+}
+inline const ::bgs::protocol::account::v1::AccountBlob& GetAccountResponse::blob() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.blob)
+  return blob_ != NULL ? *blob_ : *default_instance_->blob_;
+}
+inline ::bgs::protocol::account::v1::AccountBlob* GetAccountResponse::mutable_blob() {
+  set_has_blob();
+  if (blob_ == NULL) blob_ = new ::bgs::protocol::account::v1::AccountBlob;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.blob)
+  return blob_;
+}
+inline ::bgs::protocol::account::v1::AccountBlob* GetAccountResponse::release_blob() {
+  clear_has_blob();
+  ::bgs::protocol::account::v1::AccountBlob* temp = blob_;
+  blob_ = NULL;
+  return temp;
+}
+inline void GetAccountResponse::set_allocated_blob(::bgs::protocol::account::v1::AccountBlob* blob) {
+  delete blob_;
+  blob_ = blob;
+  if (blob) {
+    set_has_blob();
+  } else {
+    clear_has_blob();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountResponse.blob)
+}
+
+// optional .bgs.protocol.account.v1.AccountId id = 12;
+inline bool GetAccountResponse::has_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetAccountResponse::set_has_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetAccountResponse::clear_has_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetAccountResponse::clear_id() {
+  if (id_ != NULL) id_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_id();
+}
+inline const ::bgs::protocol::account::v1::AccountId& GetAccountResponse::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.id)
+  return id_ != NULL ? *id_ : *default_instance_->id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* GetAccountResponse::mutable_id() {
+  set_has_id();
+  if (id_ == NULL) id_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.id)
+  return id_;
+}
+inline ::bgs::protocol::account::v1::AccountId* GetAccountResponse::release_id() {
+  clear_has_id();
+  ::bgs::protocol::account::v1::AccountId* temp = id_;
+  id_ = NULL;
+  return temp;
+}
+inline void GetAccountResponse::set_allocated_id(::bgs::protocol::account::v1::AccountId* id) {
+  delete id_;
+  id_ = id;
+  if (id) {
+    set_has_id();
+  } else {
+    clear_has_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountResponse.id)
+}
+
+// repeated string email = 13;
+inline int GetAccountResponse::email_size() const {
+  return email_.size();
+}
+inline void GetAccountResponse::clear_email() {
+  email_.Clear();
+}
+inline const ::std::string& GetAccountResponse::email(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.email)
+  return email_.Get(index);
+}
+inline ::std::string* GetAccountResponse::mutable_email(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.email)
+  return email_.Mutable(index);
+}
+inline void GetAccountResponse::set_email(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountResponse.email)
+  email_.Mutable(index)->assign(value);
+}
+inline void GetAccountResponse::set_email(int index, const char* value) {
+  email_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GetAccountResponse.email)
+}
+inline void GetAccountResponse::set_email(int index, const char* value, size_t size) {
+  email_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GetAccountResponse.email)
+}
+inline ::std::string* GetAccountResponse::add_email() {
+  return email_.Add();
+}
+inline void GetAccountResponse::add_email(const ::std::string& value) {
+  email_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GetAccountResponse.email)
+}
+inline void GetAccountResponse::add_email(const char* value) {
+  email_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:bgs.protocol.account.v1.GetAccountResponse.email)
+}
+inline void GetAccountResponse::add_email(const char* value, size_t size) {
+  email_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:bgs.protocol.account.v1.GetAccountResponse.email)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+GetAccountResponse::email() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GetAccountResponse.email)
+  return email_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+GetAccountResponse::mutable_email() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GetAccountResponse.email)
+  return &email_;
+}
+
+// optional string battle_tag = 14;
+inline bool GetAccountResponse::has_battle_tag() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GetAccountResponse::set_has_battle_tag() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GetAccountResponse::clear_has_battle_tag() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GetAccountResponse::clear_battle_tag() {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_->clear();
+  }
+  clear_has_battle_tag();
+}
+inline const ::std::string& GetAccountResponse::battle_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.battle_tag)
+  return *battle_tag_;
+}
+inline void GetAccountResponse::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.account.v1.GetAccountResponse.battle_tag)
+}
+inline void GetAccountResponse::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.account.v1.GetAccountResponse.battle_tag)
+}
+inline void GetAccountResponse::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.account.v1.GetAccountResponse.battle_tag)
+}
+inline ::std::string* GetAccountResponse::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.account.v1.GetAccountResponse.battle_tag)
+  return battle_tag_;
+}
+inline ::std::string* GetAccountResponse::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 GetAccountResponse::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.account.v1.GetAccountResponse.battle_tag)
+}
+
+// optional string full_name = 15;
+inline bool GetAccountResponse::has_full_name() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void GetAccountResponse::set_has_full_name() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void GetAccountResponse::clear_has_full_name() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void GetAccountResponse::clear_full_name() {
+  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_->clear();
+  }
+  clear_has_full_name();
+}
+inline const ::std::string& GetAccountResponse::full_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.full_name)
+  return *full_name_;
+}
+inline void GetAccountResponse::set_full_name(const ::std::string& value) {
+  set_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_ = new ::std::string;
+  }
+  full_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountResponse.full_name)
+}
+inline void GetAccountResponse::set_full_name(const char* value) {
+  set_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_ = new ::std::string;
+  }
+  full_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GetAccountResponse.full_name)
+}
+inline void GetAccountResponse::set_full_name(const char* value, size_t size) {
+  set_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_ = new ::std::string;
+  }
+  full_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GetAccountResponse.full_name)
+}
+inline ::std::string* GetAccountResponse::mutable_full_name() {
+  set_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.full_name)
+  return full_name_;
+}
+inline ::std::string* GetAccountResponse::release_full_name() {
+  clear_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = full_name_;
+    full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void GetAccountResponse::set_allocated_full_name(::std::string* full_name) {
+  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete full_name_;
+  }
+  if (full_name) {
+    set_has_full_name();
+    full_name_ = full_name;
+  } else {
+    clear_has_full_name();
+    full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountResponse.full_name)
+}
+
+// repeated .bgs.protocol.account.v1.GameAccountLink links = 16;
+inline int GetAccountResponse::links_size() const {
+  return links_.size();
+}
+inline void GetAccountResponse::clear_links() {
+  links_.Clear();
+}
+inline const ::bgs::protocol::account::v1::GameAccountLink& GetAccountResponse::links(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.links)
+  return links_.Get(index);
+}
+inline ::bgs::protocol::account::v1::GameAccountLink* GetAccountResponse::mutable_links(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.links)
+  return links_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::GameAccountLink* GetAccountResponse::add_links() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GetAccountResponse.links)
+  return links_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >&
+GetAccountResponse::links() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GetAccountResponse.links)
+  return links_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >*
+GetAccountResponse::mutable_links() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GetAccountResponse.links)
+  return &links_;
+}
+
+// optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 17;
+inline bool GetAccountResponse::has_parental_control_info() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void GetAccountResponse::set_has_parental_control_info() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void GetAccountResponse::clear_has_parental_control_info() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void GetAccountResponse::clear_parental_control_info() {
+  if (parental_control_info_ != NULL) parental_control_info_->::bgs::protocol::account::v1::ParentalControlInfo::Clear();
+  clear_has_parental_control_info();
+}
+inline const ::bgs::protocol::account::v1::ParentalControlInfo& GetAccountResponse::parental_control_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountResponse.parental_control_info)
+  return parental_control_info_ != NULL ? *parental_control_info_ : *default_instance_->parental_control_info_;
+}
+inline ::bgs::protocol::account::v1::ParentalControlInfo* GetAccountResponse::mutable_parental_control_info() {
+  set_has_parental_control_info();
+  if (parental_control_info_ == NULL) parental_control_info_ = new ::bgs::protocol::account::v1::ParentalControlInfo;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountResponse.parental_control_info)
+  return parental_control_info_;
+}
+inline ::bgs::protocol::account::v1::ParentalControlInfo* GetAccountResponse::release_parental_control_info() {
+  clear_has_parental_control_info();
+  ::bgs::protocol::account::v1::ParentalControlInfo* temp = parental_control_info_;
+  parental_control_info_ = NULL;
+  return temp;
+}
+inline void GetAccountResponse::set_allocated_parental_control_info(::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info) {
+  delete parental_control_info_;
+  parental_control_info_ = parental_control_info;
+  if (parental_control_info) {
+    set_has_parental_control_info();
+  } else {
+    clear_has_parental_control_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountResponse.parental_control_info)
+}
+
+// -------------------------------------------------------------------
+
+// CreateGameAccountRequest
+
+// optional .bgs.protocol.account.v1.AccountId account = 1;
+inline bool CreateGameAccountRequest::has_account() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CreateGameAccountRequest::set_has_account() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CreateGameAccountRequest::clear_has_account() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CreateGameAccountRequest::clear_account() {
+  if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_account();
+}
+inline const ::bgs::protocol::account::v1::AccountId& CreateGameAccountRequest::account() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CreateGameAccountRequest.account)
+  return account_ != NULL ? *account_ : *default_instance_->account_;
+}
+inline ::bgs::protocol::account::v1::AccountId* CreateGameAccountRequest::mutable_account() {
+  set_has_account();
+  if (account_ == NULL) account_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CreateGameAccountRequest.account)
+  return account_;
+}
+inline ::bgs::protocol::account::v1::AccountId* CreateGameAccountRequest::release_account() {
+  clear_has_account();
+  ::bgs::protocol::account::v1::AccountId* temp = account_;
+  account_ = NULL;
+  return temp;
+}
+inline void CreateGameAccountRequest::set_allocated_account(::bgs::protocol::account::v1::AccountId* account) {
+  delete account_;
+  account_ = account;
+  if (account) {
+    set_has_account();
+  } else {
+    clear_has_account();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.CreateGameAccountRequest.account)
+}
+
+// optional uint32 region = 2;
+inline bool CreateGameAccountRequest::has_region() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void CreateGameAccountRequest::set_has_region() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void CreateGameAccountRequest::clear_has_region() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void CreateGameAccountRequest::clear_region() {
+  region_ = 0u;
+  clear_has_region();
+}
+inline ::google::protobuf::uint32 CreateGameAccountRequest::region() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CreateGameAccountRequest.region)
+  return region_;
+}
+inline void CreateGameAccountRequest::set_region(::google::protobuf::uint32 value) {
+  set_has_region();
+  region_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CreateGameAccountRequest.region)
+}
+
+// optional fixed32 program = 3;
+inline bool CreateGameAccountRequest::has_program() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void CreateGameAccountRequest::set_has_program() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void CreateGameAccountRequest::clear_has_program() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void CreateGameAccountRequest::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 CreateGameAccountRequest::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CreateGameAccountRequest.program)
+  return program_;
+}
+inline void CreateGameAccountRequest::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CreateGameAccountRequest.program)
+}
+
+// optional uint32 realm_permissions = 4 [default = 1];
+inline bool CreateGameAccountRequest::has_realm_permissions() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void CreateGameAccountRequest::set_has_realm_permissions() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void CreateGameAccountRequest::clear_has_realm_permissions() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void CreateGameAccountRequest::clear_realm_permissions() {
+  realm_permissions_ = 1u;
+  clear_has_realm_permissions();
+}
+inline ::google::protobuf::uint32 CreateGameAccountRequest::realm_permissions() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CreateGameAccountRequest.realm_permissions)
+  return realm_permissions_;
+}
+inline void CreateGameAccountRequest::set_realm_permissions(::google::protobuf::uint32 value) {
+  set_has_realm_permissions();
+  realm_permissions_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CreateGameAccountRequest.realm_permissions)
+}
+
+// -------------------------------------------------------------------
+
+// CacheExpireRequest
+
+// repeated .bgs.protocol.account.v1.AccountId account = 1;
+inline int CacheExpireRequest::account_size() const {
+  return account_.size();
+}
+inline void CacheExpireRequest::clear_account() {
+  account_.Clear();
+}
+inline const ::bgs::protocol::account::v1::AccountId& CacheExpireRequest::account(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CacheExpireRequest.account)
+  return account_.Get(index);
+}
+inline ::bgs::protocol::account::v1::AccountId* CacheExpireRequest::mutable_account(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CacheExpireRequest.account)
+  return account_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::AccountId* CacheExpireRequest::add_account() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.CacheExpireRequest.account)
+  return account_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountId >&
+CacheExpireRequest::account() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.CacheExpireRequest.account)
+  return account_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountId >*
+CacheExpireRequest::mutable_account() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.CacheExpireRequest.account)
+  return &account_;
+}
+
+// repeated .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
+inline int CacheExpireRequest::game_account_size() const {
+  return game_account_.size();
+}
+inline void CacheExpireRequest::clear_game_account() {
+  game_account_.Clear();
+}
+inline const ::bgs::protocol::account::v1::GameAccountHandle& CacheExpireRequest::game_account(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CacheExpireRequest.game_account)
+  return game_account_.Get(index);
+}
+inline ::bgs::protocol::account::v1::GameAccountHandle* CacheExpireRequest::mutable_game_account(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CacheExpireRequest.game_account)
+  return game_account_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::GameAccountHandle* CacheExpireRequest::add_game_account() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.CacheExpireRequest.game_account)
+  return game_account_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >&
+CacheExpireRequest::game_account() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.CacheExpireRequest.game_account)
+  return game_account_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >*
+CacheExpireRequest::mutable_game_account() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.CacheExpireRequest.game_account)
+  return &game_account_;
+}
+
+// repeated string email = 3;
+inline int CacheExpireRequest::email_size() const {
+  return email_.size();
+}
+inline void CacheExpireRequest::clear_email() {
+  email_.Clear();
+}
+inline const ::std::string& CacheExpireRequest::email(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CacheExpireRequest.email)
+  return email_.Get(index);
+}
+inline ::std::string* CacheExpireRequest::mutable_email(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CacheExpireRequest.email)
+  return email_.Mutable(index);
+}
+inline void CacheExpireRequest::set_email(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CacheExpireRequest.email)
+  email_.Mutable(index)->assign(value);
+}
+inline void CacheExpireRequest::set_email(int index, const char* value) {
+  email_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.CacheExpireRequest.email)
+}
+inline void CacheExpireRequest::set_email(int index, const char* value, size_t size) {
+  email_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.CacheExpireRequest.email)
+}
+inline ::std::string* CacheExpireRequest::add_email() {
+  return email_.Add();
+}
+inline void CacheExpireRequest::add_email(const ::std::string& value) {
+  email_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.CacheExpireRequest.email)
+}
+inline void CacheExpireRequest::add_email(const char* value) {
+  email_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:bgs.protocol.account.v1.CacheExpireRequest.email)
+}
+inline void CacheExpireRequest::add_email(const char* value, size_t size) {
+  email_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:bgs.protocol.account.v1.CacheExpireRequest.email)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+CacheExpireRequest::email() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.CacheExpireRequest.email)
+  return email_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+CacheExpireRequest::mutable_email() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.CacheExpireRequest.email)
+  return &email_;
+}
+
+// -------------------------------------------------------------------
+
+// CredentialUpdateRequest
+
+// required .bgs.protocol.account.v1.AccountId account = 1;
+inline bool CredentialUpdateRequest::has_account() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CredentialUpdateRequest::set_has_account() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CredentialUpdateRequest::clear_has_account() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CredentialUpdateRequest::clear_account() {
+  if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_account();
+}
+inline const ::bgs::protocol::account::v1::AccountId& CredentialUpdateRequest::account() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CredentialUpdateRequest.account)
+  return account_ != NULL ? *account_ : *default_instance_->account_;
+}
+inline ::bgs::protocol::account::v1::AccountId* CredentialUpdateRequest::mutable_account() {
+  set_has_account();
+  if (account_ == NULL) account_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CredentialUpdateRequest.account)
+  return account_;
+}
+inline ::bgs::protocol::account::v1::AccountId* CredentialUpdateRequest::release_account() {
+  clear_has_account();
+  ::bgs::protocol::account::v1::AccountId* temp = account_;
+  account_ = NULL;
+  return temp;
+}
+inline void CredentialUpdateRequest::set_allocated_account(::bgs::protocol::account::v1::AccountId* account) {
+  delete account_;
+  account_ = account;
+  if (account) {
+    set_has_account();
+  } else {
+    clear_has_account();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.CredentialUpdateRequest.account)
+}
+
+// repeated .bgs.protocol.account.v1.AccountCredential old_credentials = 2;
+inline int CredentialUpdateRequest::old_credentials_size() const {
+  return old_credentials_.size();
+}
+inline void CredentialUpdateRequest::clear_old_credentials() {
+  old_credentials_.Clear();
+}
+inline const ::bgs::protocol::account::v1::AccountCredential& CredentialUpdateRequest::old_credentials(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CredentialUpdateRequest.old_credentials)
+  return old_credentials_.Get(index);
+}
+inline ::bgs::protocol::account::v1::AccountCredential* CredentialUpdateRequest::mutable_old_credentials(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CredentialUpdateRequest.old_credentials)
+  return old_credentials_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::AccountCredential* CredentialUpdateRequest::add_old_credentials() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.CredentialUpdateRequest.old_credentials)
+  return old_credentials_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >&
+CredentialUpdateRequest::old_credentials() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.CredentialUpdateRequest.old_credentials)
+  return old_credentials_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >*
+CredentialUpdateRequest::mutable_old_credentials() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.CredentialUpdateRequest.old_credentials)
+  return &old_credentials_;
+}
+
+// repeated .bgs.protocol.account.v1.AccountCredential new_credentials = 3;
+inline int CredentialUpdateRequest::new_credentials_size() const {
+  return new_credentials_.size();
+}
+inline void CredentialUpdateRequest::clear_new_credentials() {
+  new_credentials_.Clear();
+}
+inline const ::bgs::protocol::account::v1::AccountCredential& CredentialUpdateRequest::new_credentials(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CredentialUpdateRequest.new_credentials)
+  return new_credentials_.Get(index);
+}
+inline ::bgs::protocol::account::v1::AccountCredential* CredentialUpdateRequest::mutable_new_credentials(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.CredentialUpdateRequest.new_credentials)
+  return new_credentials_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::AccountCredential* CredentialUpdateRequest::add_new_credentials() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.CredentialUpdateRequest.new_credentials)
+  return new_credentials_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >&
+CredentialUpdateRequest::new_credentials() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.CredentialUpdateRequest.new_credentials)
+  return new_credentials_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >*
+CredentialUpdateRequest::mutable_new_credentials() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.CredentialUpdateRequest.new_credentials)
+  return &new_credentials_;
+}
+
+// optional uint32 region = 4;
+inline bool CredentialUpdateRequest::has_region() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void CredentialUpdateRequest::set_has_region() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void CredentialUpdateRequest::clear_has_region() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void CredentialUpdateRequest::clear_region() {
+  region_ = 0u;
+  clear_has_region();
+}
+inline ::google::protobuf::uint32 CredentialUpdateRequest::region() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CredentialUpdateRequest.region)
+  return region_;
+}
+inline void CredentialUpdateRequest::set_region(::google::protobuf::uint32 value) {
+  set_has_region();
+  region_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CredentialUpdateRequest.region)
+}
+
+// -------------------------------------------------------------------
+
+// CredentialUpdateResponse
+
+// -------------------------------------------------------------------
+
+// AccountFlagUpdateRequest
+
+// optional .bgs.protocol.account.v1.AccountId account = 1;
+inline bool AccountFlagUpdateRequest::has_account() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AccountFlagUpdateRequest::set_has_account() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AccountFlagUpdateRequest::clear_has_account() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AccountFlagUpdateRequest::clear_account() {
+  if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_account();
+}
+inline const ::bgs::protocol::account::v1::AccountId& AccountFlagUpdateRequest::account() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFlagUpdateRequest.account)
+  return account_ != NULL ? *account_ : *default_instance_->account_;
+}
+inline ::bgs::protocol::account::v1::AccountId* AccountFlagUpdateRequest::mutable_account() {
+  set_has_account();
+  if (account_ == NULL) account_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountFlagUpdateRequest.account)
+  return account_;
+}
+inline ::bgs::protocol::account::v1::AccountId* AccountFlagUpdateRequest::release_account() {
+  clear_has_account();
+  ::bgs::protocol::account::v1::AccountId* temp = account_;
+  account_ = NULL;
+  return temp;
+}
+inline void AccountFlagUpdateRequest::set_allocated_account(::bgs::protocol::account::v1::AccountId* account) {
+  delete account_;
+  account_ = account;
+  if (account) {
+    set_has_account();
+  } else {
+    clear_has_account();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountFlagUpdateRequest.account)
+}
+
+// optional uint32 region = 2;
+inline bool AccountFlagUpdateRequest::has_region() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AccountFlagUpdateRequest::set_has_region() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AccountFlagUpdateRequest::clear_has_region() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AccountFlagUpdateRequest::clear_region() {
+  region_ = 0u;
+  clear_has_region();
+}
+inline ::google::protobuf::uint32 AccountFlagUpdateRequest::region() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFlagUpdateRequest.region)
+  return region_;
+}
+inline void AccountFlagUpdateRequest::set_region(::google::protobuf::uint32 value) {
+  set_has_region();
+  region_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFlagUpdateRequest.region)
+}
+
+// optional uint64 flag = 3;
+inline bool AccountFlagUpdateRequest::has_flag() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AccountFlagUpdateRequest::set_has_flag() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AccountFlagUpdateRequest::clear_has_flag() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AccountFlagUpdateRequest::clear_flag() {
+  flag_ = GOOGLE_ULONGLONG(0);
+  clear_has_flag();
+}
+inline ::google::protobuf::uint64 AccountFlagUpdateRequest::flag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFlagUpdateRequest.flag)
+  return flag_;
+}
+inline void AccountFlagUpdateRequest::set_flag(::google::protobuf::uint64 value) {
+  set_has_flag();
+  flag_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFlagUpdateRequest.flag)
+}
+
+// optional bool active = 4;
+inline bool AccountFlagUpdateRequest::has_active() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void AccountFlagUpdateRequest::set_has_active() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void AccountFlagUpdateRequest::clear_has_active() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void AccountFlagUpdateRequest::clear_active() {
+  active_ = false;
+  clear_has_active();
+}
+inline bool AccountFlagUpdateRequest::active() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFlagUpdateRequest.active)
+  return active_;
+}
+inline void AccountFlagUpdateRequest::set_active(bool value) {
+  set_has_active();
+  active_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFlagUpdateRequest.active)
+}
+
+// -------------------------------------------------------------------
+
+// GameAccountFlagUpdateRequest
+
+// optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+inline bool GameAccountFlagUpdateRequest::has_game_account() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameAccountFlagUpdateRequest::set_has_game_account() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameAccountFlagUpdateRequest::clear_has_game_account() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameAccountFlagUpdateRequest::clear_game_account() {
+  if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
+  clear_has_game_account();
+}
+inline const ::bgs::protocol::account::v1::GameAccountHandle& GameAccountFlagUpdateRequest::game_account() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.game_account)
+  return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_;
+}
+inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountFlagUpdateRequest::mutable_game_account() {
+  set_has_game_account();
+  if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.game_account)
+  return game_account_;
+}
+inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountFlagUpdateRequest::release_game_account() {
+  clear_has_game_account();
+  ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_;
+  game_account_ = NULL;
+  return temp;
+}
+inline void GameAccountFlagUpdateRequest::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) {
+  delete game_account_;
+  game_account_ = game_account;
+  if (game_account) {
+    set_has_game_account();
+  } else {
+    clear_has_game_account();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.game_account)
+}
+
+// optional uint64 flag = 2;
+inline bool GameAccountFlagUpdateRequest::has_flag() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameAccountFlagUpdateRequest::set_has_flag() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameAccountFlagUpdateRequest::clear_has_flag() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameAccountFlagUpdateRequest::clear_flag() {
+  flag_ = GOOGLE_ULONGLONG(0);
+  clear_has_flag();
+}
+inline ::google::protobuf::uint64 GameAccountFlagUpdateRequest::flag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.flag)
+  return flag_;
+}
+inline void GameAccountFlagUpdateRequest::set_flag(::google::protobuf::uint64 value) {
+  set_has_flag();
+  flag_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.flag)
+}
+
+// optional bool active = 3;
+inline bool GameAccountFlagUpdateRequest::has_active() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GameAccountFlagUpdateRequest::set_has_active() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GameAccountFlagUpdateRequest::clear_has_active() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GameAccountFlagUpdateRequest::clear_active() {
+  active_ = false;
+  clear_has_active();
+}
+inline bool GameAccountFlagUpdateRequest::active() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.active)
+  return active_;
+}
+inline void GameAccountFlagUpdateRequest::set_active(bool value) {
+  set_has_active();
+  active_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.active)
+}
+
+// -------------------------------------------------------------------
+
+// SubscriptionUpdateRequest
+
+// repeated .bgs.protocol.account.v1.SubscriberReference ref = 2;
+inline int SubscriptionUpdateRequest::ref_size() const {
+  return ref_.size();
+}
+inline void SubscriptionUpdateRequest::clear_ref() {
+  ref_.Clear();
+}
+inline const ::bgs::protocol::account::v1::SubscriberReference& SubscriptionUpdateRequest::ref(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriptionUpdateRequest.ref)
+  return ref_.Get(index);
+}
+inline ::bgs::protocol::account::v1::SubscriberReference* SubscriptionUpdateRequest::mutable_ref(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.SubscriptionUpdateRequest.ref)
+  return ref_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::SubscriberReference* SubscriptionUpdateRequest::add_ref() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.SubscriptionUpdateRequest.ref)
+  return ref_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >&
+SubscriptionUpdateRequest::ref() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.SubscriptionUpdateRequest.ref)
+  return ref_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >*
+SubscriptionUpdateRequest::mutable_ref() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.SubscriptionUpdateRequest.ref)
+  return &ref_;
+}
+
+// -------------------------------------------------------------------
+
+// SubscriptionUpdateResponse
+
+// repeated .bgs.protocol.account.v1.SubscriberReference ref = 1;
+inline int SubscriptionUpdateResponse::ref_size() const {
+  return ref_.size();
+}
+inline void SubscriptionUpdateResponse::clear_ref() {
+  ref_.Clear();
+}
+inline const ::bgs::protocol::account::v1::SubscriberReference& SubscriptionUpdateResponse::ref(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriptionUpdateResponse.ref)
+  return ref_.Get(index);
+}
+inline ::bgs::protocol::account::v1::SubscriberReference* SubscriptionUpdateResponse::mutable_ref(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.SubscriptionUpdateResponse.ref)
+  return ref_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::SubscriberReference* SubscriptionUpdateResponse::add_ref() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.SubscriptionUpdateResponse.ref)
+  return ref_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >&
+SubscriptionUpdateResponse::ref() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.SubscriptionUpdateResponse.ref)
+  return ref_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >*
+SubscriptionUpdateResponse::mutable_ref() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.SubscriptionUpdateResponse.ref)
+  return &ref_;
+}
+
+// -------------------------------------------------------------------
+
+// IsIgrAddressRequest
+
+// optional string client_address = 1;
+inline bool IsIgrAddressRequest::has_client_address() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void IsIgrAddressRequest::set_has_client_address() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void IsIgrAddressRequest::clear_has_client_address() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void IsIgrAddressRequest::clear_client_address() {
+  if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_address_->clear();
+  }
+  clear_has_client_address();
+}
+inline const ::std::string& IsIgrAddressRequest::client_address() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.IsIgrAddressRequest.client_address)
+  return *client_address_;
+}
+inline void IsIgrAddressRequest::set_client_address(const ::std::string& value) {
+  set_has_client_address();
+  if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_address_ = new ::std::string;
+  }
+  client_address_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.IsIgrAddressRequest.client_address)
+}
+inline void IsIgrAddressRequest::set_client_address(const char* value) {
+  set_has_client_address();
+  if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_address_ = new ::std::string;
+  }
+  client_address_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.IsIgrAddressRequest.client_address)
+}
+inline void IsIgrAddressRequest::set_client_address(const char* value, size_t size) {
+  set_has_client_address();
+  if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_address_ = new ::std::string;
+  }
+  client_address_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.IsIgrAddressRequest.client_address)
+}
+inline ::std::string* IsIgrAddressRequest::mutable_client_address() {
+  set_has_client_address();
+  if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_address_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.IsIgrAddressRequest.client_address)
+  return client_address_;
+}
+inline ::std::string* IsIgrAddressRequest::release_client_address() {
+  clear_has_client_address();
+  if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = client_address_;
+    client_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void IsIgrAddressRequest::set_allocated_client_address(::std::string* client_address) {
+  if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_address_;
+  }
+  if (client_address) {
+    set_has_client_address();
+    client_address_ = client_address;
+  } else {
+    clear_has_client_address();
+    client_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.IsIgrAddressRequest.client_address)
+}
+
+// optional uint32 region = 2;
+inline bool IsIgrAddressRequest::has_region() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void IsIgrAddressRequest::set_has_region() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void IsIgrAddressRequest::clear_has_region() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void IsIgrAddressRequest::clear_region() {
+  region_ = 0u;
+  clear_has_region();
+}
+inline ::google::protobuf::uint32 IsIgrAddressRequest::region() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.IsIgrAddressRequest.region)
+  return region_;
+}
+inline void IsIgrAddressRequest::set_region(::google::protobuf::uint32 value) {
+  set_has_region();
+  region_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.IsIgrAddressRequest.region)
+}
+
+// -------------------------------------------------------------------
+
+// AccountServiceRegion
+
+// required uint32 id = 1;
+inline bool AccountServiceRegion::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AccountServiceRegion::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AccountServiceRegion::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AccountServiceRegion::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 AccountServiceRegion::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountServiceRegion.id)
+  return id_;
+}
+inline void AccountServiceRegion::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountServiceRegion.id)
+}
+
+// required string shard = 2;
+inline bool AccountServiceRegion::has_shard() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AccountServiceRegion::set_has_shard() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AccountServiceRegion::clear_has_shard() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AccountServiceRegion::clear_shard() {
+  if (shard_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    shard_->clear();
+  }
+  clear_has_shard();
+}
+inline const ::std::string& AccountServiceRegion::shard() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountServiceRegion.shard)
+  return *shard_;
+}
+inline void AccountServiceRegion::set_shard(const ::std::string& value) {
+  set_has_shard();
+  if (shard_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    shard_ = new ::std::string;
+  }
+  shard_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountServiceRegion.shard)
+}
+inline void AccountServiceRegion::set_shard(const char* value) {
+  set_has_shard();
+  if (shard_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    shard_ = new ::std::string;
+  }
+  shard_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountServiceRegion.shard)
+}
+inline void AccountServiceRegion::set_shard(const char* value, size_t size) {
+  set_has_shard();
+  if (shard_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    shard_ = new ::std::string;
+  }
+  shard_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountServiceRegion.shard)
+}
+inline ::std::string* AccountServiceRegion::mutable_shard() {
+  set_has_shard();
+  if (shard_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    shard_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountServiceRegion.shard)
+  return shard_;
+}
+inline ::std::string* AccountServiceRegion::release_shard() {
+  clear_has_shard();
+  if (shard_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = shard_;
+    shard_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void AccountServiceRegion::set_allocated_shard(::std::string* shard) {
+  if (shard_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete shard_;
+  }
+  if (shard) {
+    set_has_shard();
+    shard_ = shard;
+  } else {
+    clear_has_shard();
+    shard_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountServiceRegion.shard)
+}
+
+// -------------------------------------------------------------------
+
+// AccountServiceConfig
+
+// repeated .bgs.protocol.account.v1.AccountServiceRegion region = 1;
+inline int AccountServiceConfig::region_size() const {
+  return region_.size();
+}
+inline void AccountServiceConfig::clear_region() {
+  region_.Clear();
+}
+inline const ::bgs::protocol::account::v1::AccountServiceRegion& AccountServiceConfig::region(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountServiceConfig.region)
+  return region_.Get(index);
+}
+inline ::bgs::protocol::account::v1::AccountServiceRegion* AccountServiceConfig::mutable_region(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountServiceConfig.region)
+  return region_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::AccountServiceRegion* AccountServiceConfig::add_region() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountServiceConfig.region)
+  return region_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountServiceRegion >&
+AccountServiceConfig::region() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountServiceConfig.region)
+  return region_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountServiceRegion >*
+AccountServiceConfig::mutable_region() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountServiceConfig.region)
+  return &region_;
+}
+
+// -------------------------------------------------------------------
+
+// GetAccountStateRequest
+
+// optional .bgs.protocol.EntityId entity_id = 1;
+inline bool GetAccountStateRequest::has_entity_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetAccountStateRequest::set_has_entity_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetAccountStateRequest::clear_has_entity_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetAccountStateRequest::clear_entity_id() {
+  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id();
+}
+inline const ::bgs::protocol::EntityId& GetAccountStateRequest::entity_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateRequest.entity_id)
+  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
+}
+inline ::bgs::protocol::EntityId* GetAccountStateRequest::mutable_entity_id() {
+  set_has_entity_id();
+  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountStateRequest.entity_id)
+  return entity_id_;
+}
+inline ::bgs::protocol::EntityId* GetAccountStateRequest::release_entity_id() {
+  clear_has_entity_id();
+  ::bgs::protocol::EntityId* temp = entity_id_;
+  entity_id_ = NULL;
+  return temp;
+}
+inline void GetAccountStateRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
+  delete entity_id_;
+  entity_id_ = entity_id;
+  if (entity_id) {
+    set_has_entity_id();
+  } else {
+    clear_has_entity_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountStateRequest.entity_id)
+}
+
+// optional uint32 program = 2;
+inline bool GetAccountStateRequest::has_program() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetAccountStateRequest::set_has_program() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetAccountStateRequest::clear_has_program() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetAccountStateRequest::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 GetAccountStateRequest::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateRequest.program)
+  return program_;
+}
+inline void GetAccountStateRequest::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountStateRequest.program)
+}
+
+// optional uint32 region = 3;
+inline bool GetAccountStateRequest::has_region() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetAccountStateRequest::set_has_region() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetAccountStateRequest::clear_has_region() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetAccountStateRequest::clear_region() {
+  region_ = 0u;
+  clear_has_region();
+}
+inline ::google::protobuf::uint32 GetAccountStateRequest::region() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateRequest.region)
+  return region_;
+}
+inline void GetAccountStateRequest::set_region(::google::protobuf::uint32 value) {
+  set_has_region();
+  region_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountStateRequest.region)
+}
+
+// optional .bgs.protocol.account.v1.AccountFieldOptions options = 10;
+inline bool GetAccountStateRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GetAccountStateRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GetAccountStateRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GetAccountStateRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::account::v1::AccountFieldOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::account::v1::AccountFieldOptions& GetAccountStateRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::account::v1::AccountFieldOptions* GetAccountStateRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::account::v1::AccountFieldOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountStateRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::account::v1::AccountFieldOptions* GetAccountStateRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::account::v1::AccountFieldOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void GetAccountStateRequest::set_allocated_options(::bgs::protocol::account::v1::AccountFieldOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountStateRequest.options)
+}
+
+// optional .bgs.protocol.account.v1.AccountFieldTags tags = 11;
+inline bool GetAccountStateRequest::has_tags() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void GetAccountStateRequest::set_has_tags() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void GetAccountStateRequest::clear_has_tags() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void GetAccountStateRequest::clear_tags() {
+  if (tags_ != NULL) tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear();
+  clear_has_tags();
+}
+inline const ::bgs::protocol::account::v1::AccountFieldTags& GetAccountStateRequest::tags() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateRequest.tags)
+  return tags_ != NULL ? *tags_ : *default_instance_->tags_;
+}
+inline ::bgs::protocol::account::v1::AccountFieldTags* GetAccountStateRequest::mutable_tags() {
+  set_has_tags();
+  if (tags_ == NULL) tags_ = new ::bgs::protocol::account::v1::AccountFieldTags;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountStateRequest.tags)
+  return tags_;
+}
+inline ::bgs::protocol::account::v1::AccountFieldTags* GetAccountStateRequest::release_tags() {
+  clear_has_tags();
+  ::bgs::protocol::account::v1::AccountFieldTags* temp = tags_;
+  tags_ = NULL;
+  return temp;
+}
+inline void GetAccountStateRequest::set_allocated_tags(::bgs::protocol::account::v1::AccountFieldTags* tags) {
+  delete tags_;
+  tags_ = tags;
+  if (tags) {
+    set_has_tags();
+  } else {
+    clear_has_tags();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountStateRequest.tags)
+}
+
+// -------------------------------------------------------------------
+
+// GetAccountStateResponse
+
+// optional .bgs.protocol.account.v1.AccountState state = 1;
+inline bool GetAccountStateResponse::has_state() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetAccountStateResponse::set_has_state() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetAccountStateResponse::clear_has_state() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetAccountStateResponse::clear_state() {
+  if (state_ != NULL) state_->::bgs::protocol::account::v1::AccountState::Clear();
+  clear_has_state();
+}
+inline const ::bgs::protocol::account::v1::AccountState& GetAccountStateResponse::state() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateResponse.state)
+  return state_ != NULL ? *state_ : *default_instance_->state_;
+}
+inline ::bgs::protocol::account::v1::AccountState* GetAccountStateResponse::mutable_state() {
+  set_has_state();
+  if (state_ == NULL) state_ = new ::bgs::protocol::account::v1::AccountState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountStateResponse.state)
+  return state_;
+}
+inline ::bgs::protocol::account::v1::AccountState* GetAccountStateResponse::release_state() {
+  clear_has_state();
+  ::bgs::protocol::account::v1::AccountState* temp = state_;
+  state_ = NULL;
+  return temp;
+}
+inline void GetAccountStateResponse::set_allocated_state(::bgs::protocol::account::v1::AccountState* state) {
+  delete state_;
+  state_ = state;
+  if (state) {
+    set_has_state();
+  } else {
+    clear_has_state();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountStateResponse.state)
+}
+
+// optional .bgs.protocol.account.v1.AccountFieldTags tags = 2;
+inline bool GetAccountStateResponse::has_tags() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetAccountStateResponse::set_has_tags() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetAccountStateResponse::clear_has_tags() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetAccountStateResponse::clear_tags() {
+  if (tags_ != NULL) tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear();
+  clear_has_tags();
+}
+inline const ::bgs::protocol::account::v1::AccountFieldTags& GetAccountStateResponse::tags() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateResponse.tags)
+  return tags_ != NULL ? *tags_ : *default_instance_->tags_;
+}
+inline ::bgs::protocol::account::v1::AccountFieldTags* GetAccountStateResponse::mutable_tags() {
+  set_has_tags();
+  if (tags_ == NULL) tags_ = new ::bgs::protocol::account::v1::AccountFieldTags;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountStateResponse.tags)
+  return tags_;
+}
+inline ::bgs::protocol::account::v1::AccountFieldTags* GetAccountStateResponse::release_tags() {
+  clear_has_tags();
+  ::bgs::protocol::account::v1::AccountFieldTags* temp = tags_;
+  tags_ = NULL;
+  return temp;
+}
+inline void GetAccountStateResponse::set_allocated_tags(::bgs::protocol::account::v1::AccountFieldTags* tags) {
+  delete tags_;
+  tags_ = tags;
+  if (tags) {
+    set_has_tags();
+  } else {
+    clear_has_tags();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountStateResponse.tags)
+}
+
+// -------------------------------------------------------------------
+
+// GetGameAccountStateRequest
+
+// optional .bgs.protocol.EntityId account_id = 1 [deprecated = true];
+inline bool GetGameAccountStateRequest::has_account_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetGameAccountStateRequest::set_has_account_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetGameAccountStateRequest::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetGameAccountStateRequest::clear_account_id() {
+  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_account_id();
+}
+inline const ::bgs::protocol::EntityId& GetGameAccountStateRequest::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateRequest.account_id)
+  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
+}
+inline ::bgs::protocol::EntityId* GetGameAccountStateRequest::mutable_account_id() {
+  set_has_account_id();
+  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateRequest.account_id)
+  return account_id_;
+}
+inline ::bgs::protocol::EntityId* GetGameAccountStateRequest::release_account_id() {
+  clear_has_account_id();
+  ::bgs::protocol::EntityId* temp = account_id_;
+  account_id_ = NULL;
+  return temp;
+}
+inline void GetGameAccountStateRequest::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.account.v1.GetGameAccountStateRequest.account_id)
+}
+
+// optional .bgs.protocol.EntityId game_account_id = 2;
+inline bool GetGameAccountStateRequest::has_game_account_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetGameAccountStateRequest::set_has_game_account_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetGameAccountStateRequest::clear_has_game_account_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetGameAccountStateRequest::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& GetGameAccountStateRequest::game_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateRequest.game_account_id)
+  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
+}
+inline ::bgs::protocol::EntityId* GetGameAccountStateRequest::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.account.v1.GetGameAccountStateRequest.game_account_id)
+  return game_account_id_;
+}
+inline ::bgs::protocol::EntityId* GetGameAccountStateRequest::release_game_account_id() {
+  clear_has_game_account_id();
+  ::bgs::protocol::EntityId* temp = game_account_id_;
+  game_account_id_ = NULL;
+  return temp;
+}
+inline void GetGameAccountStateRequest::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.account.v1.GetGameAccountStateRequest.game_account_id)
+}
+
+// optional .bgs.protocol.account.v1.GameAccountFieldOptions options = 10;
+inline bool GetGameAccountStateRequest::has_options() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetGameAccountStateRequest::set_has_options() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetGameAccountStateRequest::clear_has_options() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetGameAccountStateRequest::clear_options() {
+  if (options_ != NULL) options_->::bgs::protocol::account::v1::GameAccountFieldOptions::Clear();
+  clear_has_options();
+}
+inline const ::bgs::protocol::account::v1::GameAccountFieldOptions& GetGameAccountStateRequest::options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateRequest.options)
+  return options_ != NULL ? *options_ : *default_instance_->options_;
+}
+inline ::bgs::protocol::account::v1::GameAccountFieldOptions* GetGameAccountStateRequest::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) options_ = new ::bgs::protocol::account::v1::GameAccountFieldOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateRequest.options)
+  return options_;
+}
+inline ::bgs::protocol::account::v1::GameAccountFieldOptions* GetGameAccountStateRequest::release_options() {
+  clear_has_options();
+  ::bgs::protocol::account::v1::GameAccountFieldOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline void GetGameAccountStateRequest::set_allocated_options(::bgs::protocol::account::v1::GameAccountFieldOptions* options) {
+  delete options_;
+  options_ = options;
+  if (options) {
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountStateRequest.options)
+}
+
+// optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 11;
+inline bool GetGameAccountStateRequest::has_tags() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GetGameAccountStateRequest::set_has_tags() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GetGameAccountStateRequest::clear_has_tags() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GetGameAccountStateRequest::clear_tags() {
+  if (tags_ != NULL) tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear();
+  clear_has_tags();
+}
+inline const ::bgs::protocol::account::v1::GameAccountFieldTags& GetGameAccountStateRequest::tags() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateRequest.tags)
+  return tags_ != NULL ? *tags_ : *default_instance_->tags_;
+}
+inline ::bgs::protocol::account::v1::GameAccountFieldTags* GetGameAccountStateRequest::mutable_tags() {
+  set_has_tags();
+  if (tags_ == NULL) tags_ = new ::bgs::protocol::account::v1::GameAccountFieldTags;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateRequest.tags)
+  return tags_;
+}
+inline ::bgs::protocol::account::v1::GameAccountFieldTags* GetGameAccountStateRequest::release_tags() {
+  clear_has_tags();
+  ::bgs::protocol::account::v1::GameAccountFieldTags* temp = tags_;
+  tags_ = NULL;
+  return temp;
+}
+inline void GetGameAccountStateRequest::set_allocated_tags(::bgs::protocol::account::v1::GameAccountFieldTags* tags) {
+  delete tags_;
+  tags_ = tags;
+  if (tags) {
+    set_has_tags();
+  } else {
+    clear_has_tags();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountStateRequest.tags)
+}
+
+// -------------------------------------------------------------------
+
+// GetGameAccountStateResponse
+
+// optional .bgs.protocol.account.v1.GameAccountState state = 1;
+inline bool GetGameAccountStateResponse::has_state() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetGameAccountStateResponse::set_has_state() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetGameAccountStateResponse::clear_has_state() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetGameAccountStateResponse::clear_state() {
+  if (state_ != NULL) state_->::bgs::protocol::account::v1::GameAccountState::Clear();
+  clear_has_state();
+}
+inline const ::bgs::protocol::account::v1::GameAccountState& GetGameAccountStateResponse::state() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateResponse.state)
+  return state_ != NULL ? *state_ : *default_instance_->state_;
+}
+inline ::bgs::protocol::account::v1::GameAccountState* GetGameAccountStateResponse::mutable_state() {
+  set_has_state();
+  if (state_ == NULL) state_ = new ::bgs::protocol::account::v1::GameAccountState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateResponse.state)
+  return state_;
+}
+inline ::bgs::protocol::account::v1::GameAccountState* GetGameAccountStateResponse::release_state() {
+  clear_has_state();
+  ::bgs::protocol::account::v1::GameAccountState* temp = state_;
+  state_ = NULL;
+  return temp;
+}
+inline void GetGameAccountStateResponse::set_allocated_state(::bgs::protocol::account::v1::GameAccountState* state) {
+  delete state_;
+  state_ = state;
+  if (state) {
+    set_has_state();
+  } else {
+    clear_has_state();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountStateResponse.state)
+}
+
+// optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 2;
+inline bool GetGameAccountStateResponse::has_tags() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetGameAccountStateResponse::set_has_tags() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetGameAccountStateResponse::clear_has_tags() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetGameAccountStateResponse::clear_tags() {
+  if (tags_ != NULL) tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear();
+  clear_has_tags();
+}
+inline const ::bgs::protocol::account::v1::GameAccountFieldTags& GetGameAccountStateResponse::tags() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateResponse.tags)
+  return tags_ != NULL ? *tags_ : *default_instance_->tags_;
+}
+inline ::bgs::protocol::account::v1::GameAccountFieldTags* GetGameAccountStateResponse::mutable_tags() {
+  set_has_tags();
+  if (tags_ == NULL) tags_ = new ::bgs::protocol::account::v1::GameAccountFieldTags;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateResponse.tags)
+  return tags_;
+}
+inline ::bgs::protocol::account::v1::GameAccountFieldTags* GetGameAccountStateResponse::release_tags() {
+  clear_has_tags();
+  ::bgs::protocol::account::v1::GameAccountFieldTags* temp = tags_;
+  tags_ = NULL;
+  return temp;
+}
+inline void GetGameAccountStateResponse::set_allocated_tags(::bgs::protocol::account::v1::GameAccountFieldTags* tags) {
+  delete tags_;
+  tags_ = tags;
+  if (tags) {
+    set_has_tags();
+  } else {
+    clear_has_tags();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountStateResponse.tags)
+}
+
+// -------------------------------------------------------------------
+
+// GetLicensesRequest
+
+// optional .bgs.protocol.EntityId target_id = 1;
+inline bool GetLicensesRequest::has_target_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetLicensesRequest::set_has_target_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetLicensesRequest::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetLicensesRequest::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::EntityId& GetLicensesRequest::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::EntityId* GetLicensesRequest::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetLicensesRequest.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::EntityId* GetLicensesRequest::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::EntityId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void GetLicensesRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetLicensesRequest.target_id)
+}
+
+// optional bool fetch_account_licenses = 2;
+inline bool GetLicensesRequest::has_fetch_account_licenses() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetLicensesRequest::set_has_fetch_account_licenses() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetLicensesRequest::clear_has_fetch_account_licenses() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetLicensesRequest::clear_fetch_account_licenses() {
+  fetch_account_licenses_ = false;
+  clear_has_fetch_account_licenses();
+}
+inline bool GetLicensesRequest::fetch_account_licenses() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.fetch_account_licenses)
+  return fetch_account_licenses_;
+}
+inline void GetLicensesRequest::set_fetch_account_licenses(bool value) {
+  set_has_fetch_account_licenses();
+  fetch_account_licenses_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetLicensesRequest.fetch_account_licenses)
+}
+
+// optional bool fetch_game_account_licenses = 3;
+inline bool GetLicensesRequest::has_fetch_game_account_licenses() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetLicensesRequest::set_has_fetch_game_account_licenses() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetLicensesRequest::clear_has_fetch_game_account_licenses() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetLicensesRequest::clear_fetch_game_account_licenses() {
+  fetch_game_account_licenses_ = false;
+  clear_has_fetch_game_account_licenses();
+}
+inline bool GetLicensesRequest::fetch_game_account_licenses() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.fetch_game_account_licenses)
+  return fetch_game_account_licenses_;
+}
+inline void GetLicensesRequest::set_fetch_game_account_licenses(bool value) {
+  set_has_fetch_game_account_licenses();
+  fetch_game_account_licenses_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetLicensesRequest.fetch_game_account_licenses)
+}
+
+// optional bool fetch_dynamic_account_licenses = 4;
+inline bool GetLicensesRequest::has_fetch_dynamic_account_licenses() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GetLicensesRequest::set_has_fetch_dynamic_account_licenses() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GetLicensesRequest::clear_has_fetch_dynamic_account_licenses() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GetLicensesRequest::clear_fetch_dynamic_account_licenses() {
+  fetch_dynamic_account_licenses_ = false;
+  clear_has_fetch_dynamic_account_licenses();
+}
+inline bool GetLicensesRequest::fetch_dynamic_account_licenses() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.fetch_dynamic_account_licenses)
+  return fetch_dynamic_account_licenses_;
+}
+inline void GetLicensesRequest::set_fetch_dynamic_account_licenses(bool value) {
+  set_has_fetch_dynamic_account_licenses();
+  fetch_dynamic_account_licenses_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetLicensesRequest.fetch_dynamic_account_licenses)
+}
+
+// optional fixed32 program = 5;
+inline bool GetLicensesRequest::has_program() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void GetLicensesRequest::set_has_program() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void GetLicensesRequest::clear_has_program() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void GetLicensesRequest::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 GetLicensesRequest::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.program)
+  return program_;
+}
+inline void GetLicensesRequest::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetLicensesRequest.program)
+}
+
+// optional bool exclude_unknown_program = 6 [default = false];
+inline bool GetLicensesRequest::has_exclude_unknown_program() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void GetLicensesRequest::set_has_exclude_unknown_program() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void GetLicensesRequest::clear_has_exclude_unknown_program() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void GetLicensesRequest::clear_exclude_unknown_program() {
+  exclude_unknown_program_ = false;
+  clear_has_exclude_unknown_program();
+}
+inline bool GetLicensesRequest::exclude_unknown_program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.exclude_unknown_program)
+  return exclude_unknown_program_;
+}
+inline void GetLicensesRequest::set_exclude_unknown_program(bool value) {
+  set_has_exclude_unknown_program();
+  exclude_unknown_program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetLicensesRequest.exclude_unknown_program)
+}
+
+// -------------------------------------------------------------------
+
+// GetLicensesResponse
+
+// repeated .bgs.protocol.account.v1.AccountLicense licenses = 1;
+inline int GetLicensesResponse::licenses_size() const {
+  return licenses_.size();
+}
+inline void GetLicensesResponse::clear_licenses() {
+  licenses_.Clear();
+}
+inline const ::bgs::protocol::account::v1::AccountLicense& GetLicensesResponse::licenses(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesResponse.licenses)
+  return licenses_.Get(index);
+}
+inline ::bgs::protocol::account::v1::AccountLicense* GetLicensesResponse::mutable_licenses(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetLicensesResponse.licenses)
+  return licenses_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::AccountLicense* GetLicensesResponse::add_licenses() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GetLicensesResponse.licenses)
+  return licenses_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >&
+GetLicensesResponse::licenses() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GetLicensesResponse.licenses)
+  return licenses_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >*
+GetLicensesResponse::mutable_licenses() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GetLicensesResponse.licenses)
+  return &licenses_;
+}
+
+// -------------------------------------------------------------------
+
+// GetGameSessionInfoRequest
+
+// optional .bgs.protocol.EntityId entity_id = 1;
+inline bool GetGameSessionInfoRequest::has_entity_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetGameSessionInfoRequest::set_has_entity_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetGameSessionInfoRequest::clear_has_entity_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetGameSessionInfoRequest::clear_entity_id() {
+  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id();
+}
+inline const ::bgs::protocol::EntityId& GetGameSessionInfoRequest::entity_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameSessionInfoRequest.entity_id)
+  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
+}
+inline ::bgs::protocol::EntityId* GetGameSessionInfoRequest::mutable_entity_id() {
+  set_has_entity_id();
+  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameSessionInfoRequest.entity_id)
+  return entity_id_;
+}
+inline ::bgs::protocol::EntityId* GetGameSessionInfoRequest::release_entity_id() {
+  clear_has_entity_id();
+  ::bgs::protocol::EntityId* temp = entity_id_;
+  entity_id_ = NULL;
+  return temp;
+}
+inline void GetGameSessionInfoRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
+  delete entity_id_;
+  entity_id_ = entity_id;
+  if (entity_id) {
+    set_has_entity_id();
+  } else {
+    clear_has_entity_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameSessionInfoRequest.entity_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetGameSessionInfoResponse
+
+// optional .bgs.protocol.account.v1.GameSessionInfo session_info = 2;
+inline bool GetGameSessionInfoResponse::has_session_info() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetGameSessionInfoResponse::set_has_session_info() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetGameSessionInfoResponse::clear_has_session_info() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetGameSessionInfoResponse::clear_session_info() {
+  if (session_info_ != NULL) session_info_->::bgs::protocol::account::v1::GameSessionInfo::Clear();
+  clear_has_session_info();
+}
+inline const ::bgs::protocol::account::v1::GameSessionInfo& GetGameSessionInfoResponse::session_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameSessionInfoResponse.session_info)
+  return session_info_ != NULL ? *session_info_ : *default_instance_->session_info_;
+}
+inline ::bgs::protocol::account::v1::GameSessionInfo* GetGameSessionInfoResponse::mutable_session_info() {
+  set_has_session_info();
+  if (session_info_ == NULL) session_info_ = new ::bgs::protocol::account::v1::GameSessionInfo;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameSessionInfoResponse.session_info)
+  return session_info_;
+}
+inline ::bgs::protocol::account::v1::GameSessionInfo* GetGameSessionInfoResponse::release_session_info() {
+  clear_has_session_info();
+  ::bgs::protocol::account::v1::GameSessionInfo* temp = session_info_;
+  session_info_ = NULL;
+  return temp;
+}
+inline void GetGameSessionInfoResponse::set_allocated_session_info(::bgs::protocol::account::v1::GameSessionInfo* session_info) {
+  delete session_info_;
+  session_info_ = session_info;
+  if (session_info) {
+    set_has_session_info();
+  } else {
+    clear_has_session_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameSessionInfoResponse.session_info)
+}
+
+// -------------------------------------------------------------------
+
+// GetGameTimeRemainingInfoRequest
+
+// optional .bgs.protocol.EntityId game_account_id = 1;
+inline bool GetGameTimeRemainingInfoRequest::has_game_account_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetGameTimeRemainingInfoRequest::set_has_game_account_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetGameTimeRemainingInfoRequest::clear_has_game_account_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetGameTimeRemainingInfoRequest::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& GetGameTimeRemainingInfoRequest::game_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.game_account_id)
+  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
+}
+inline ::bgs::protocol::EntityId* GetGameTimeRemainingInfoRequest::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.account.v1.GetGameTimeRemainingInfoRequest.game_account_id)
+  return game_account_id_;
+}
+inline ::bgs::protocol::EntityId* GetGameTimeRemainingInfoRequest::release_game_account_id() {
+  clear_has_game_account_id();
+  ::bgs::protocol::EntityId* temp = game_account_id_;
+  game_account_id_ = NULL;
+  return temp;
+}
+inline void GetGameTimeRemainingInfoRequest::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.account.v1.GetGameTimeRemainingInfoRequest.game_account_id)
+}
+
+// optional .bgs.protocol.EntityId account_id = 2;
+inline bool GetGameTimeRemainingInfoRequest::has_account_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetGameTimeRemainingInfoRequest::set_has_account_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetGameTimeRemainingInfoRequest::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetGameTimeRemainingInfoRequest::clear_account_id() {
+  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_account_id();
+}
+inline const ::bgs::protocol::EntityId& GetGameTimeRemainingInfoRequest::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.account_id)
+  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
+}
+inline ::bgs::protocol::EntityId* GetGameTimeRemainingInfoRequest::mutable_account_id() {
+  set_has_account_id();
+  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.account_id)
+  return account_id_;
+}
+inline ::bgs::protocol::EntityId* GetGameTimeRemainingInfoRequest::release_account_id() {
+  clear_has_account_id();
+  ::bgs::protocol::EntityId* temp = account_id_;
+  account_id_ = NULL;
+  return temp;
+}
+inline void GetGameTimeRemainingInfoRequest::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.account.v1.GetGameTimeRemainingInfoRequest.account_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetGameTimeRemainingInfoResponse
+
+// optional .bgs.protocol.account.v1.GameTimeRemainingInfo game_time_remaining_info = 1;
+inline bool GetGameTimeRemainingInfoResponse::has_game_time_remaining_info() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetGameTimeRemainingInfoResponse::set_has_game_time_remaining_info() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetGameTimeRemainingInfoResponse::clear_has_game_time_remaining_info() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetGameTimeRemainingInfoResponse::clear_game_time_remaining_info() {
+  if (game_time_remaining_info_ != NULL) game_time_remaining_info_->::bgs::protocol::account::v1::GameTimeRemainingInfo::Clear();
+  clear_has_game_time_remaining_info();
+}
+inline const ::bgs::protocol::account::v1::GameTimeRemainingInfo& GetGameTimeRemainingInfoResponse::game_time_remaining_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse.game_time_remaining_info)
+  return game_time_remaining_info_ != NULL ? *game_time_remaining_info_ : *default_instance_->game_time_remaining_info_;
+}
+inline ::bgs::protocol::account::v1::GameTimeRemainingInfo* GetGameTimeRemainingInfoResponse::mutable_game_time_remaining_info() {
+  set_has_game_time_remaining_info();
+  if (game_time_remaining_info_ == NULL) game_time_remaining_info_ = new ::bgs::protocol::account::v1::GameTimeRemainingInfo;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse.game_time_remaining_info)
+  return game_time_remaining_info_;
+}
+inline ::bgs::protocol::account::v1::GameTimeRemainingInfo* GetGameTimeRemainingInfoResponse::release_game_time_remaining_info() {
+  clear_has_game_time_remaining_info();
+  ::bgs::protocol::account::v1::GameTimeRemainingInfo* temp = game_time_remaining_info_;
+  game_time_remaining_info_ = NULL;
+  return temp;
+}
+inline void GetGameTimeRemainingInfoResponse::set_allocated_game_time_remaining_info(::bgs::protocol::account::v1::GameTimeRemainingInfo* game_time_remaining_info) {
+  delete game_time_remaining_info_;
+  game_time_remaining_info_ = game_time_remaining_info;
+  if (game_time_remaining_info) {
+    set_has_game_time_remaining_info();
+  } else {
+    clear_has_game_time_remaining_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse.game_time_remaining_info)
+}
+
+// -------------------------------------------------------------------
+
+// GetCAISInfoRequest
+
+// optional .bgs.protocol.EntityId entity_id = 1;
+inline bool GetCAISInfoRequest::has_entity_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetCAISInfoRequest::set_has_entity_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetCAISInfoRequest::clear_has_entity_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetCAISInfoRequest::clear_entity_id() {
+  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id();
+}
+inline const ::bgs::protocol::EntityId& GetCAISInfoRequest::entity_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetCAISInfoRequest.entity_id)
+  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
+}
+inline ::bgs::protocol::EntityId* GetCAISInfoRequest::mutable_entity_id() {
+  set_has_entity_id();
+  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetCAISInfoRequest.entity_id)
+  return entity_id_;
+}
+inline ::bgs::protocol::EntityId* GetCAISInfoRequest::release_entity_id() {
+  clear_has_entity_id();
+  ::bgs::protocol::EntityId* temp = entity_id_;
+  entity_id_ = NULL;
+  return temp;
+}
+inline void GetCAISInfoRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
+  delete entity_id_;
+  entity_id_ = entity_id;
+  if (entity_id) {
+    set_has_entity_id();
+  } else {
+    clear_has_entity_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetCAISInfoRequest.entity_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetCAISInfoResponse
+
+// optional .bgs.protocol.account.v1.CAIS cais_info = 1;
+inline bool GetCAISInfoResponse::has_cais_info() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetCAISInfoResponse::set_has_cais_info() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetCAISInfoResponse::clear_has_cais_info() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetCAISInfoResponse::clear_cais_info() {
+  if (cais_info_ != NULL) cais_info_->::bgs::protocol::account::v1::CAIS::Clear();
+  clear_has_cais_info();
+}
+inline const ::bgs::protocol::account::v1::CAIS& GetCAISInfoResponse::cais_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetCAISInfoResponse.cais_info)
+  return cais_info_ != NULL ? *cais_info_ : *default_instance_->cais_info_;
+}
+inline ::bgs::protocol::account::v1::CAIS* GetCAISInfoResponse::mutable_cais_info() {
+  set_has_cais_info();
+  if (cais_info_ == NULL) cais_info_ = new ::bgs::protocol::account::v1::CAIS;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetCAISInfoResponse.cais_info)
+  return cais_info_;
+}
+inline ::bgs::protocol::account::v1::CAIS* GetCAISInfoResponse::release_cais_info() {
+  clear_has_cais_info();
+  ::bgs::protocol::account::v1::CAIS* temp = cais_info_;
+  cais_info_ = NULL;
+  return temp;
+}
+inline void GetCAISInfoResponse::set_allocated_cais_info(::bgs::protocol::account::v1::CAIS* cais_info) {
+  delete cais_info_;
+  cais_info_ = cais_info;
+  if (cais_info) {
+    set_has_cais_info();
+  } else {
+    clear_has_cais_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetCAISInfoResponse.cais_info)
+}
+
+// -------------------------------------------------------------------
+
+// ForwardCacheExpireRequest
+
+// optional .bgs.protocol.EntityId entity_id = 1;
+inline bool ForwardCacheExpireRequest::has_entity_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ForwardCacheExpireRequest::set_has_entity_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ForwardCacheExpireRequest::clear_has_entity_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ForwardCacheExpireRequest::clear_entity_id() {
+  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id();
+}
+inline const ::bgs::protocol::EntityId& ForwardCacheExpireRequest::entity_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ForwardCacheExpireRequest.entity_id)
+  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
+}
+inline ::bgs::protocol::EntityId* ForwardCacheExpireRequest::mutable_entity_id() {
+  set_has_entity_id();
+  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.ForwardCacheExpireRequest.entity_id)
+  return entity_id_;
+}
+inline ::bgs::protocol::EntityId* ForwardCacheExpireRequest::release_entity_id() {
+  clear_has_entity_id();
+  ::bgs::protocol::EntityId* temp = entity_id_;
+  entity_id_ = NULL;
+  return temp;
+}
+inline void ForwardCacheExpireRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
+  delete entity_id_;
+  entity_id_ = entity_id;
+  if (entity_id) {
+    set_has_entity_id();
+  } else {
+    clear_has_entity_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.ForwardCacheExpireRequest.entity_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetAuthorizedDataRequest
+
+// optional .bgs.protocol.EntityId entity_id = 1;
+inline bool GetAuthorizedDataRequest::has_entity_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetAuthorizedDataRequest::set_has_entity_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetAuthorizedDataRequest::clear_has_entity_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetAuthorizedDataRequest::clear_entity_id() {
+  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id();
+}
+inline const ::bgs::protocol::EntityId& GetAuthorizedDataRequest::entity_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAuthorizedDataRequest.entity_id)
+  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
+}
+inline ::bgs::protocol::EntityId* GetAuthorizedDataRequest::mutable_entity_id() {
+  set_has_entity_id();
+  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAuthorizedDataRequest.entity_id)
+  return entity_id_;
+}
+inline ::bgs::protocol::EntityId* GetAuthorizedDataRequest::release_entity_id() {
+  clear_has_entity_id();
+  ::bgs::protocol::EntityId* temp = entity_id_;
+  entity_id_ = NULL;
+  return temp;
+}
+inline void GetAuthorizedDataRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
+  delete entity_id_;
+  entity_id_ = entity_id;
+  if (entity_id) {
+    set_has_entity_id();
+  } else {
+    clear_has_entity_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAuthorizedDataRequest.entity_id)
+}
+
+// repeated string tag = 2;
+inline int GetAuthorizedDataRequest::tag_size() const {
+  return tag_.size();
+}
+inline void GetAuthorizedDataRequest::clear_tag() {
+  tag_.Clear();
+}
+inline const ::std::string& GetAuthorizedDataRequest::tag(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
+  return tag_.Get(index);
+}
+inline ::std::string* GetAuthorizedDataRequest::mutable_tag(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
+  return tag_.Mutable(index);
+}
+inline void GetAuthorizedDataRequest::set_tag(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
+  tag_.Mutable(index)->assign(value);
+}
+inline void GetAuthorizedDataRequest::set_tag(int index, const char* value) {
+  tag_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
+}
+inline void GetAuthorizedDataRequest::set_tag(int index, const char* value, size_t size) {
+  tag_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
+}
+inline ::std::string* GetAuthorizedDataRequest::add_tag() {
+  return tag_.Add();
+}
+inline void GetAuthorizedDataRequest::add_tag(const ::std::string& value) {
+  tag_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
+}
+inline void GetAuthorizedDataRequest::add_tag(const char* value) {
+  tag_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
+}
+inline void GetAuthorizedDataRequest::add_tag(const char* value, size_t size) {
+  tag_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+GetAuthorizedDataRequest::tag() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
+  return tag_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+GetAuthorizedDataRequest::mutable_tag() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
+  return &tag_;
+}
+
+// optional bool privileged_network = 3;
+inline bool GetAuthorizedDataRequest::has_privileged_network() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetAuthorizedDataRequest::set_has_privileged_network() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetAuthorizedDataRequest::clear_has_privileged_network() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetAuthorizedDataRequest::clear_privileged_network() {
+  privileged_network_ = false;
+  clear_has_privileged_network();
+}
+inline bool GetAuthorizedDataRequest::privileged_network() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAuthorizedDataRequest.privileged_network)
+  return privileged_network_;
+}
+inline void GetAuthorizedDataRequest::set_privileged_network(bool value) {
+  set_has_privileged_network();
+  privileged_network_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAuthorizedDataRequest.privileged_network)
+}
+
+// -------------------------------------------------------------------
+
+// GetAuthorizedDataResponse
+
+// repeated .bgs.protocol.account.v1.AuthorizedData data = 1;
+inline int GetAuthorizedDataResponse::data_size() const {
+  return data_.size();
+}
+inline void GetAuthorizedDataResponse::clear_data() {
+  data_.Clear();
+}
+inline const ::bgs::protocol::account::v1::AuthorizedData& GetAuthorizedDataResponse::data(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAuthorizedDataResponse.data)
+  return data_.Get(index);
+}
+inline ::bgs::protocol::account::v1::AuthorizedData* GetAuthorizedDataResponse::mutable_data(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAuthorizedDataResponse.data)
+  return data_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::AuthorizedData* GetAuthorizedDataResponse::add_data() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GetAuthorizedDataResponse.data)
+  return data_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AuthorizedData >&
+GetAuthorizedDataResponse::data() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GetAuthorizedDataResponse.data)
+  return data_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AuthorizedData >*
+GetAuthorizedDataResponse::mutable_data() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GetAuthorizedDataResponse.data)
+  return &data_;
+}
+
+// -------------------------------------------------------------------
+
+// AccountStateNotification
+
+// optional .bgs.protocol.account.v1.AccountState account_state = 1;
+inline bool AccountStateNotification::has_account_state() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AccountStateNotification::set_has_account_state() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AccountStateNotification::clear_has_account_state() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AccountStateNotification::clear_account_state() {
+  if (account_state_ != NULL) account_state_->::bgs::protocol::account::v1::AccountState::Clear();
+  clear_has_account_state();
+}
+inline const ::bgs::protocol::account::v1::AccountState& AccountStateNotification::account_state() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountStateNotification.account_state)
+  return account_state_ != NULL ? *account_state_ : *default_instance_->account_state_;
+}
+inline ::bgs::protocol::account::v1::AccountState* AccountStateNotification::mutable_account_state() {
+  set_has_account_state();
+  if (account_state_ == NULL) account_state_ = new ::bgs::protocol::account::v1::AccountState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountStateNotification.account_state)
+  return account_state_;
+}
+inline ::bgs::protocol::account::v1::AccountState* AccountStateNotification::release_account_state() {
+  clear_has_account_state();
+  ::bgs::protocol::account::v1::AccountState* temp = account_state_;
+  account_state_ = NULL;
+  return temp;
+}
+inline void AccountStateNotification::set_allocated_account_state(::bgs::protocol::account::v1::AccountState* account_state) {
+  delete account_state_;
+  account_state_ = account_state;
+  if (account_state) {
+    set_has_account_state();
+  } else {
+    clear_has_account_state();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountStateNotification.account_state)
+}
+
+// optional uint64 subscriber_id = 2;
+inline bool AccountStateNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AccountStateNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AccountStateNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AccountStateNotification::clear_subscriber_id() {
+  subscriber_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_subscriber_id();
+}
+inline ::google::protobuf::uint64 AccountStateNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountStateNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline void AccountStateNotification::set_subscriber_id(::google::protobuf::uint64 value) {
+  set_has_subscriber_id();
+  subscriber_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountStateNotification.subscriber_id)
+}
+
+// optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
+inline bool AccountStateNotification::has_account_tags() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AccountStateNotification::set_has_account_tags() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AccountStateNotification::clear_has_account_tags() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AccountStateNotification::clear_account_tags() {
+  if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear();
+  clear_has_account_tags();
+}
+inline const ::bgs::protocol::account::v1::AccountFieldTags& AccountStateNotification::account_tags() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountStateNotification.account_tags)
+  return account_tags_ != NULL ? *account_tags_ : *default_instance_->account_tags_;
+}
+inline ::bgs::protocol::account::v1::AccountFieldTags* AccountStateNotification::mutable_account_tags() {
+  set_has_account_tags();
+  if (account_tags_ == NULL) account_tags_ = new ::bgs::protocol::account::v1::AccountFieldTags;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountStateNotification.account_tags)
+  return account_tags_;
+}
+inline ::bgs::protocol::account::v1::AccountFieldTags* AccountStateNotification::release_account_tags() {
+  clear_has_account_tags();
+  ::bgs::protocol::account::v1::AccountFieldTags* temp = account_tags_;
+  account_tags_ = NULL;
+  return temp;
+}
+inline void AccountStateNotification::set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags) {
+  delete account_tags_;
+  account_tags_ = account_tags;
+  if (account_tags) {
+    set_has_account_tags();
+  } else {
+    clear_has_account_tags();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountStateNotification.account_tags)
+}
+
+// optional bool subscription_completed = 4;
+inline bool AccountStateNotification::has_subscription_completed() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void AccountStateNotification::set_has_subscription_completed() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void AccountStateNotification::clear_has_subscription_completed() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void AccountStateNotification::clear_subscription_completed() {
+  subscription_completed_ = false;
+  clear_has_subscription_completed();
+}
+inline bool AccountStateNotification::subscription_completed() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountStateNotification.subscription_completed)
+  return subscription_completed_;
+}
+inline void AccountStateNotification::set_subscription_completed(bool value) {
+  set_has_subscription_completed();
+  subscription_completed_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountStateNotification.subscription_completed)
+}
+
+// -------------------------------------------------------------------
+
+// GameAccountStateNotification
+
+// optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1;
+inline bool GameAccountStateNotification::has_game_account_state() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameAccountStateNotification::set_has_game_account_state() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameAccountStateNotification::clear_has_game_account_state() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameAccountStateNotification::clear_game_account_state() {
+  if (game_account_state_ != NULL) game_account_state_->::bgs::protocol::account::v1::GameAccountState::Clear();
+  clear_has_game_account_state();
+}
+inline const ::bgs::protocol::account::v1::GameAccountState& GameAccountStateNotification::game_account_state() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountStateNotification.game_account_state)
+  return game_account_state_ != NULL ? *game_account_state_ : *default_instance_->game_account_state_;
+}
+inline ::bgs::protocol::account::v1::GameAccountState* GameAccountStateNotification::mutable_game_account_state() {
+  set_has_game_account_state();
+  if (game_account_state_ == NULL) game_account_state_ = new ::bgs::protocol::account::v1::GameAccountState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountStateNotification.game_account_state)
+  return game_account_state_;
+}
+inline ::bgs::protocol::account::v1::GameAccountState* GameAccountStateNotification::release_game_account_state() {
+  clear_has_game_account_state();
+  ::bgs::protocol::account::v1::GameAccountState* temp = game_account_state_;
+  game_account_state_ = NULL;
+  return temp;
+}
+inline void GameAccountStateNotification::set_allocated_game_account_state(::bgs::protocol::account::v1::GameAccountState* game_account_state) {
+  delete game_account_state_;
+  game_account_state_ = game_account_state;
+  if (game_account_state) {
+    set_has_game_account_state();
+  } else {
+    clear_has_game_account_state();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountStateNotification.game_account_state)
+}
+
+// optional uint64 subscriber_id = 2;
+inline bool GameAccountStateNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameAccountStateNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameAccountStateNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameAccountStateNotification::clear_subscriber_id() {
+  subscriber_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_subscriber_id();
+}
+inline ::google::protobuf::uint64 GameAccountStateNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountStateNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline void GameAccountStateNotification::set_subscriber_id(::google::protobuf::uint64 value) {
+  set_has_subscriber_id();
+  subscriber_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountStateNotification.subscriber_id)
+}
+
+// optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 3;
+inline bool GameAccountStateNotification::has_game_account_tags() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GameAccountStateNotification::set_has_game_account_tags() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GameAccountStateNotification::clear_has_game_account_tags() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GameAccountStateNotification::clear_game_account_tags() {
+  if (game_account_tags_ != NULL) game_account_tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear();
+  clear_has_game_account_tags();
+}
+inline const ::bgs::protocol::account::v1::GameAccountFieldTags& GameAccountStateNotification::game_account_tags() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountStateNotification.game_account_tags)
+  return game_account_tags_ != NULL ? *game_account_tags_ : *default_instance_->game_account_tags_;
+}
+inline ::bgs::protocol::account::v1::GameAccountFieldTags* GameAccountStateNotification::mutable_game_account_tags() {
+  set_has_game_account_tags();
+  if (game_account_tags_ == NULL) game_account_tags_ = new ::bgs::protocol::account::v1::GameAccountFieldTags;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountStateNotification.game_account_tags)
+  return game_account_tags_;
+}
+inline ::bgs::protocol::account::v1::GameAccountFieldTags* GameAccountStateNotification::release_game_account_tags() {
+  clear_has_game_account_tags();
+  ::bgs::protocol::account::v1::GameAccountFieldTags* temp = game_account_tags_;
+  game_account_tags_ = NULL;
+  return temp;
+}
+inline void GameAccountStateNotification::set_allocated_game_account_tags(::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags) {
+  delete game_account_tags_;
+  game_account_tags_ = game_account_tags;
+  if (game_account_tags) {
+    set_has_game_account_tags();
+  } else {
+    clear_has_game_account_tags();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountStateNotification.game_account_tags)
+}
+
+// optional bool subscription_completed = 4;
+inline bool GameAccountStateNotification::has_subscription_completed() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GameAccountStateNotification::set_has_subscription_completed() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GameAccountStateNotification::clear_has_subscription_completed() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GameAccountStateNotification::clear_subscription_completed() {
+  subscription_completed_ = false;
+  clear_has_subscription_completed();
+}
+inline bool GameAccountStateNotification::subscription_completed() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountStateNotification.subscription_completed)
+  return subscription_completed_;
+}
+inline void GameAccountStateNotification::set_subscription_completed(bool value) {
+  set_has_subscription_completed();
+  subscription_completed_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountStateNotification.subscription_completed)
+}
+
+// -------------------------------------------------------------------
+
+// GameAccountNotification
+
+// repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 1;
+inline int GameAccountNotification::game_accounts_size() const {
+  return game_accounts_.size();
+}
+inline void GameAccountNotification::clear_game_accounts() {
+  game_accounts_.Clear();
+}
+inline const ::bgs::protocol::account::v1::GameAccountList& GameAccountNotification::game_accounts(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountNotification.game_accounts)
+  return game_accounts_.Get(index);
+}
+inline ::bgs::protocol::account::v1::GameAccountList* GameAccountNotification::mutable_game_accounts(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountNotification.game_accounts)
+  return game_accounts_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::GameAccountList* GameAccountNotification::add_game_accounts() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GameAccountNotification.game_accounts)
+  return game_accounts_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >&
+GameAccountNotification::game_accounts() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GameAccountNotification.game_accounts)
+  return game_accounts_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >*
+GameAccountNotification::mutable_game_accounts() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GameAccountNotification.game_accounts)
+  return &game_accounts_;
+}
+
+// optional uint64 subscriber_id = 2;
+inline bool GameAccountNotification::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameAccountNotification::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameAccountNotification::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameAccountNotification::clear_subscriber_id() {
+  subscriber_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_subscriber_id();
+}
+inline ::google::protobuf::uint64 GameAccountNotification::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountNotification.subscriber_id)
+  return subscriber_id_;
+}
+inline void GameAccountNotification::set_subscriber_id(::google::protobuf::uint64 value) {
+  set_has_subscriber_id();
+  subscriber_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountNotification.subscriber_id)
+}
+
+// optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
+inline bool GameAccountNotification::has_account_tags() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GameAccountNotification::set_has_account_tags() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GameAccountNotification::clear_has_account_tags() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GameAccountNotification::clear_account_tags() {
+  if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear();
+  clear_has_account_tags();
+}
+inline const ::bgs::protocol::account::v1::AccountFieldTags& GameAccountNotification::account_tags() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountNotification.account_tags)
+  return account_tags_ != NULL ? *account_tags_ : *default_instance_->account_tags_;
+}
+inline ::bgs::protocol::account::v1::AccountFieldTags* GameAccountNotification::mutable_account_tags() {
+  set_has_account_tags();
+  if (account_tags_ == NULL) account_tags_ = new ::bgs::protocol::account::v1::AccountFieldTags;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountNotification.account_tags)
+  return account_tags_;
+}
+inline ::bgs::protocol::account::v1::AccountFieldTags* GameAccountNotification::release_account_tags() {
+  clear_has_account_tags();
+  ::bgs::protocol::account::v1::AccountFieldTags* temp = account_tags_;
+  account_tags_ = NULL;
+  return temp;
+}
+inline void GameAccountNotification::set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags) {
+  delete account_tags_;
+  account_tags_ = account_tags;
+  if (account_tags) {
+    set_has_account_tags();
+  } else {
+    clear_has_account_tags();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountNotification.account_tags)
+}
+
+// -------------------------------------------------------------------
+
+// GameAccountSessionNotification
+
+// optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+inline bool GameAccountSessionNotification::has_game_account() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameAccountSessionNotification::set_has_game_account() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameAccountSessionNotification::clear_has_game_account() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameAccountSessionNotification::clear_game_account() {
+  if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
+  clear_has_game_account();
+}
+inline const ::bgs::protocol::account::v1::GameAccountHandle& GameAccountSessionNotification::game_account() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountSessionNotification.game_account)
+  return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_;
+}
+inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountSessionNotification::mutable_game_account() {
+  set_has_game_account();
+  if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountSessionNotification.game_account)
+  return game_account_;
+}
+inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountSessionNotification::release_game_account() {
+  clear_has_game_account();
+  ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_;
+  game_account_ = NULL;
+  return temp;
+}
+inline void GameAccountSessionNotification::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) {
+  delete game_account_;
+  game_account_ = game_account;
+  if (game_account) {
+    set_has_game_account();
+  } else {
+    clear_has_game_account();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountSessionNotification.game_account)
+}
+
+// optional .bgs.protocol.account.v1.GameSessionUpdateInfo session_info = 2;
+inline bool GameAccountSessionNotification::has_session_info() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameAccountSessionNotification::set_has_session_info() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameAccountSessionNotification::clear_has_session_info() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameAccountSessionNotification::clear_session_info() {
+  if (session_info_ != NULL) session_info_->::bgs::protocol::account::v1::GameSessionUpdateInfo::Clear();
+  clear_has_session_info();
+}
+inline const ::bgs::protocol::account::v1::GameSessionUpdateInfo& GameAccountSessionNotification::session_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountSessionNotification.session_info)
+  return session_info_ != NULL ? *session_info_ : *default_instance_->session_info_;
+}
+inline ::bgs::protocol::account::v1::GameSessionUpdateInfo* GameAccountSessionNotification::mutable_session_info() {
+  set_has_session_info();
+  if (session_info_ == NULL) session_info_ = new ::bgs::protocol::account::v1::GameSessionUpdateInfo;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountSessionNotification.session_info)
+  return session_info_;
+}
+inline ::bgs::protocol::account::v1::GameSessionUpdateInfo* GameAccountSessionNotification::release_session_info() {
+  clear_has_session_info();
+  ::bgs::protocol::account::v1::GameSessionUpdateInfo* temp = session_info_;
+  session_info_ = NULL;
+  return temp;
+}
+inline void GameAccountSessionNotification::set_allocated_session_info(::bgs::protocol::account::v1::GameSessionUpdateInfo* session_info) {
+  delete session_info_;
+  session_info_ = session_info;
+  if (session_info) {
+    set_has_session_info();
+  } else {
+    clear_has_session_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountSessionNotification.session_info)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace account
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_account_5fservice_2eproto__INCLUDED
diff --git a/src/server/proto/Client/account_types.pb.cc b/src/server/proto/Client/account_types.pb.cc
new file mode 100644
index 00000000000..9659cfa2c84
--- /dev/null
+++ b/src/server/proto/Client/account_types.pb.cc
@@ -0,0 +1,15012 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: account_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "account_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace account {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* AccountId_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountId_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountLicense_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountLicense_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountCredential_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountCredential_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountBlob_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountBlob_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountBlobList_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountBlobList_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameAccountHandle_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameAccountHandle_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameAccountLink_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameAccountLink_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameAccountBlob_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameAccountBlob_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameAccountBlobList_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameAccountBlobList_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountReference_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountReference_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Identity_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Identity_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ProgramTag_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ProgramTag_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RegionTag_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RegionTag_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountFieldTags_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountFieldTags_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameAccountFieldTags_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameAccountFieldTags_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountFieldOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountFieldOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameAccountFieldOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameAccountFieldOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SubscriberReference_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscriberReference_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountLevelInfo_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountLevelInfo_reflection_ = NULL;
+const ::google::protobuf::Descriptor* PrivacyInfo_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  PrivacyInfo_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* PrivacyInfo_GameInfoPrivacy_descriptor_ = NULL;
+const ::google::protobuf::Descriptor* ParentalControlInfo_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ParentalControlInfo_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameLevelInfo_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameLevelInfo_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameTimeInfo_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameTimeInfo_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameTimeRemainingInfo_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameTimeRemainingInfo_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameStatus_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameStatus_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RAFInfo_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RAFInfo_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameSessionInfo_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameSessionInfo_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameSessionUpdateInfo_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameSessionUpdateInfo_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameSessionLocation_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameSessionLocation_reflection_ = NULL;
+const ::google::protobuf::Descriptor* CAIS_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  CAIS_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameAccountList_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameAccountList_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountState_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountState_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountStateTagged_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountStateTagged_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameAccountState_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameAccountState_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameAccountStateTagged_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameAccountStateTagged_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AuthorizedData_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AuthorizedData_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* IdentityVerificationStatus_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_account_5ftypes_2eproto() {
+  protobuf_AddDesc_account_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "account_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  AccountId_descriptor_ = file->message_type(0);
+  static const int AccountId_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountId, id_),
+  };
+  AccountId_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountId_descriptor_,
+      AccountId::default_instance_,
+      AccountId_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountId, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountId, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountId));
+  AccountLicense_descriptor_ = file->message_type(1);
+  static const int AccountLicense_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLicense, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLicense, expires_),
+  };
+  AccountLicense_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountLicense_descriptor_,
+      AccountLicense::default_instance_,
+      AccountLicense_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLicense, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLicense, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountLicense));
+  AccountCredential_descriptor_ = file->message_type(2);
+  static const int AccountCredential_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountCredential, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountCredential, data_),
+  };
+  AccountCredential_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountCredential_descriptor_,
+      AccountCredential::default_instance_,
+      AccountCredential_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountCredential, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountCredential, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountCredential));
+  AccountBlob_descriptor_ = file->message_type(3);
+  static const int AccountBlob_offsets_[20] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, region_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, email_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, flags_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, secure_release_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, whitelist_start_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, whitelist_end_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, full_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, licenses_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, credentials_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, account_links_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, battle_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, default_currency_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, legal_region_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, legal_locale_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, cache_expiration_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, parental_control_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, country_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, preferred_region_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, identity_check_status_),
+  };
+  AccountBlob_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountBlob_descriptor_,
+      AccountBlob::default_instance_,
+      AccountBlob_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlob, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountBlob));
+  AccountBlobList_descriptor_ = file->message_type(4);
+  static const int AccountBlobList_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlobList, blob_),
+  };
+  AccountBlobList_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountBlobList_descriptor_,
+      AccountBlobList::default_instance_,
+      AccountBlobList_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlobList, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountBlobList, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountBlobList));
+  GameAccountHandle_descriptor_ = file->message_type(5);
+  static const int GameAccountHandle_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountHandle, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountHandle, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountHandle, region_),
+  };
+  GameAccountHandle_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameAccountHandle_descriptor_,
+      GameAccountHandle::default_instance_,
+      GameAccountHandle_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountHandle, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountHandle, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameAccountHandle));
+  GameAccountLink_descriptor_ = file->message_type(6);
+  static const int GameAccountLink_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountLink, game_account_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountLink, name_),
+  };
+  GameAccountLink_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameAccountLink_descriptor_,
+      GameAccountLink::default_instance_,
+      GameAccountLink_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountLink, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountLink, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameAccountLink));
+  GameAccountBlob_descriptor_ = file->message_type(7);
+  static const int GameAccountBlob_offsets_[16] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, game_account_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, realm_permissions_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, status_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, flags_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, billing_flags_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, cache_expiration_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, subscription_expiration_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, units_remaining_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, status_expiration_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, box_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, box_level_expiration_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, licenses_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, raf_account_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, raf_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, raf_expiration_),
+  };
+  GameAccountBlob_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameAccountBlob_descriptor_,
+      GameAccountBlob::default_instance_,
+      GameAccountBlob_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlob, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameAccountBlob));
+  GameAccountBlobList_descriptor_ = file->message_type(8);
+  static const int GameAccountBlobList_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlobList, blob_),
+  };
+  GameAccountBlobList_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameAccountBlobList_descriptor_,
+      GameAccountBlobList::default_instance_,
+      GameAccountBlobList_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlobList, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountBlobList, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameAccountBlobList));
+  AccountReference_descriptor_ = file->message_type(9);
+  static const int AccountReference_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountReference, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountReference, email_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountReference, handle_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountReference, battle_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountReference, region_),
+  };
+  AccountReference_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountReference_descriptor_,
+      AccountReference::default_instance_,
+      AccountReference_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountReference, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountReference, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountReference));
+  Identity_descriptor_ = file->message_type(10);
+  static const int Identity_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, account_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, game_account_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, process_),
+  };
+  Identity_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Identity_descriptor_,
+      Identity::default_instance_,
+      Identity_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Identity));
+  ProgramTag_descriptor_ = file->message_type(11);
+  static const int ProgramTag_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProgramTag, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProgramTag, tag_),
+  };
+  ProgramTag_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ProgramTag_descriptor_,
+      ProgramTag::default_instance_,
+      ProgramTag_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProgramTag, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProgramTag, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ProgramTag));
+  RegionTag_descriptor_ = file->message_type(12);
+  static const int RegionTag_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RegionTag, region_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RegionTag, tag_),
+  };
+  RegionTag_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RegionTag_descriptor_,
+      RegionTag::default_instance_,
+      RegionTag_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RegionTag, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RegionTag, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RegionTag));
+  AccountFieldTags_descriptor_ = file->message_type(13);
+  static const int AccountFieldTags_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, account_level_info_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, privacy_info_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, parental_control_info_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, game_level_info_tags_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, game_status_tags_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, game_account_tags_),
+  };
+  AccountFieldTags_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountFieldTags_descriptor_,
+      AccountFieldTags::default_instance_,
+      AccountFieldTags_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldTags, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountFieldTags));
+  GameAccountFieldTags_descriptor_ = file->message_type(14);
+  static const int GameAccountFieldTags_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldTags, game_level_info_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldTags, game_time_info_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldTags, game_status_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldTags, raf_info_tag_),
+  };
+  GameAccountFieldTags_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameAccountFieldTags_descriptor_,
+      GameAccountFieldTags::default_instance_,
+      GameAccountFieldTags_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldTags, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldTags, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameAccountFieldTags));
+  AccountFieldOptions_descriptor_ = file->message_type(15);
+  static const int AccountFieldOptions_offsets_[7] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, all_fields_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, field_account_level_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, field_privacy_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, field_parental_control_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, field_game_level_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, field_game_status_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, field_game_accounts_),
+  };
+  AccountFieldOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountFieldOptions_descriptor_,
+      AccountFieldOptions::default_instance_,
+      AccountFieldOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountFieldOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountFieldOptions));
+  GameAccountFieldOptions_descriptor_ = file->message_type(16);
+  static const int GameAccountFieldOptions_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldOptions, all_fields_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldOptions, field_game_level_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldOptions, field_game_time_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldOptions, field_game_status_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldOptions, field_raf_info_),
+  };
+  GameAccountFieldOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameAccountFieldOptions_descriptor_,
+      GameAccountFieldOptions::default_instance_,
+      GameAccountFieldOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountFieldOptions, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameAccountFieldOptions));
+  SubscriberReference_descriptor_ = file->message_type(17);
+  static const int SubscriberReference_offsets_[7] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, object_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, entity_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, account_options_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, account_tags_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, game_account_options_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, game_account_tags_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, subscriber_id_),
+  };
+  SubscriberReference_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscriberReference_descriptor_,
+      SubscriberReference::default_instance_,
+      SubscriberReference_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscriberReference, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscriberReference));
+  AccountLevelInfo_descriptor_ = file->message_type(18);
+  static const int AccountLevelInfo_offsets_[11] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, licenses_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, default_currency_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, country_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, preferred_region_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, full_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, battle_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, muted_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, manual_review_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, account_paid_any_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, identity_check_status_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, email_),
+  };
+  AccountLevelInfo_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountLevelInfo_descriptor_,
+      AccountLevelInfo::default_instance_,
+      AccountLevelInfo_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountLevelInfo, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountLevelInfo));
+  PrivacyInfo_descriptor_ = file->message_type(19);
+  static const int PrivacyInfo_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, is_using_rid_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, is_real_id_visible_for_view_friends_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, is_hidden_from_friend_finder_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, game_info_privacy_),
+  };
+  PrivacyInfo_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      PrivacyInfo_descriptor_,
+      PrivacyInfo::default_instance_,
+      PrivacyInfo_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PrivacyInfo, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(PrivacyInfo));
+  PrivacyInfo_GameInfoPrivacy_descriptor_ = PrivacyInfo_descriptor_->enum_type(0);
+  ParentalControlInfo_descriptor_ = file->message_type(20);
+  static const int ParentalControlInfo_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, timezone_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, minutes_per_day_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, minutes_per_week_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, can_receive_voice_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, can_send_voice_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, play_schedule_),
+  };
+  ParentalControlInfo_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ParentalControlInfo_descriptor_,
+      ParentalControlInfo::default_instance_,
+      ParentalControlInfo_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParentalControlInfo, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ParentalControlInfo));
+  GameLevelInfo_descriptor_ = file->message_type(21);
+  static const int GameLevelInfo_offsets_[8] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, is_trial_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, is_lifetime_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, is_restricted_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, is_beta_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, licenses_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, realm_permissions_),
+  };
+  GameLevelInfo_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameLevelInfo_descriptor_,
+      GameLevelInfo::default_instance_,
+      GameLevelInfo_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameLevelInfo, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameLevelInfo));
+  GameTimeInfo_descriptor_ = file->message_type(22);
+  static const int GameTimeInfo_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeInfo, is_unlimited_play_time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeInfo, play_time_expires_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeInfo, is_subscription_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeInfo, is_recurring_subscription_),
+  };
+  GameTimeInfo_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameTimeInfo_descriptor_,
+      GameTimeInfo::default_instance_,
+      GameTimeInfo_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeInfo, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeInfo, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameTimeInfo));
+  GameTimeRemainingInfo_descriptor_ = file->message_type(23);
+  static const int GameTimeRemainingInfo_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeRemainingInfo, minutes_remaining_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeRemainingInfo, parental_daily_minutes_remaining_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeRemainingInfo, parental_weekly_minutes_remaining_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeRemainingInfo, seconds_remaining_until_kick_),
+  };
+  GameTimeRemainingInfo_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameTimeRemainingInfo_descriptor_,
+      GameTimeRemainingInfo::default_instance_,
+      GameTimeRemainingInfo_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeRemainingInfo, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameTimeRemainingInfo, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameTimeRemainingInfo));
+  GameStatus_descriptor_ = file->message_type(24);
+  static const int GameStatus_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, is_suspended_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, is_banned_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, suspension_expires_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, is_locked_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, is_bam_unlockable_),
+  };
+  GameStatus_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameStatus_descriptor_,
+      GameStatus::default_instance_,
+      GameStatus_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameStatus, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameStatus));
+  RAFInfo_descriptor_ = file->message_type(25);
+  static const int RAFInfo_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RAFInfo, raf_info_),
+  };
+  RAFInfo_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RAFInfo_descriptor_,
+      RAFInfo::default_instance_,
+      RAFInfo_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RAFInfo, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RAFInfo, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RAFInfo));
+  GameSessionInfo_descriptor_ = file->message_type(26);
+  static const int GameSessionInfo_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, start_time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, location_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, has_benefactor_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, is_using_igr_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, parental_controls_active_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, start_time_sec_),
+  };
+  GameSessionInfo_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameSessionInfo_descriptor_,
+      GameSessionInfo::default_instance_,
+      GameSessionInfo_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionInfo, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameSessionInfo));
+  GameSessionUpdateInfo_descriptor_ = file->message_type(27);
+  static const int GameSessionUpdateInfo_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionUpdateInfo, cais_),
+  };
+  GameSessionUpdateInfo_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameSessionUpdateInfo_descriptor_,
+      GameSessionUpdateInfo::default_instance_,
+      GameSessionUpdateInfo_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionUpdateInfo, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionUpdateInfo, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameSessionUpdateInfo));
+  GameSessionLocation_descriptor_ = file->message_type(28);
+  static const int GameSessionLocation_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionLocation, ip_address_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionLocation, country_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionLocation, city_),
+  };
+  GameSessionLocation_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameSessionLocation_descriptor_,
+      GameSessionLocation::default_instance_,
+      GameSessionLocation_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionLocation, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameSessionLocation, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameSessionLocation));
+  CAIS_descriptor_ = file->message_type(29);
+  static const int CAIS_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CAIS, played_minutes_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CAIS, rested_minutes_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CAIS, last_heard_time_),
+  };
+  CAIS_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      CAIS_descriptor_,
+      CAIS::default_instance_,
+      CAIS_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CAIS, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CAIS, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(CAIS));
+  GameAccountList_descriptor_ = file->message_type(30);
+  static const int GameAccountList_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountList, region_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountList, handle_),
+  };
+  GameAccountList_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameAccountList_descriptor_,
+      GameAccountList::default_instance_,
+      GameAccountList_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountList, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountList, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameAccountList));
+  AccountState_descriptor_ = file->message_type(31);
+  static const int AccountState_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, account_level_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, privacy_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, parental_control_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, game_level_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, game_status_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, game_accounts_),
+  };
+  AccountState_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountState_descriptor_,
+      AccountState::default_instance_,
+      AccountState_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountState, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountState));
+  AccountStateTagged_descriptor_ = file->message_type(32);
+  static const int AccountStateTagged_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateTagged, account_state_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateTagged, account_tags_),
+  };
+  AccountStateTagged_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountStateTagged_descriptor_,
+      AccountStateTagged::default_instance_,
+      AccountStateTagged_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateTagged, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountStateTagged, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountStateTagged));
+  GameAccountState_descriptor_ = file->message_type(33);
+  static const int GameAccountState_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountState, game_level_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountState, game_time_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountState, game_status_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountState, raf_info_),
+  };
+  GameAccountState_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameAccountState_descriptor_,
+      GameAccountState::default_instance_,
+      GameAccountState_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountState, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountState, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameAccountState));
+  GameAccountStateTagged_descriptor_ = file->message_type(34);
+  static const int GameAccountStateTagged_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateTagged, game_account_state_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateTagged, game_account_tags_),
+  };
+  GameAccountStateTagged_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameAccountStateTagged_descriptor_,
+      GameAccountStateTagged::default_instance_,
+      GameAccountStateTagged_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateTagged, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountStateTagged, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameAccountStateTagged));
+  AuthorizedData_descriptor_ = file->message_type(35);
+  static const int AuthorizedData_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthorizedData, data_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthorizedData, license_),
+  };
+  AuthorizedData_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AuthorizedData_descriptor_,
+      AuthorizedData::default_instance_,
+      AuthorizedData_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthorizedData, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AuthorizedData, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AuthorizedData));
+  IdentityVerificationStatus_descriptor_ = file->enum_type(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_account_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountId_descriptor_, &AccountId::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountLicense_descriptor_, &AccountLicense::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountCredential_descriptor_, &AccountCredential::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountBlob_descriptor_, &AccountBlob::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountBlobList_descriptor_, &AccountBlobList::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameAccountHandle_descriptor_, &GameAccountHandle::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameAccountLink_descriptor_, &GameAccountLink::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameAccountBlob_descriptor_, &GameAccountBlob::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameAccountBlobList_descriptor_, &GameAccountBlobList::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountReference_descriptor_, &AccountReference::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Identity_descriptor_, &Identity::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ProgramTag_descriptor_, &ProgramTag::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RegionTag_descriptor_, &RegionTag::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountFieldTags_descriptor_, &AccountFieldTags::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameAccountFieldTags_descriptor_, &GameAccountFieldTags::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountFieldOptions_descriptor_, &AccountFieldOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameAccountFieldOptions_descriptor_, &GameAccountFieldOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscriberReference_descriptor_, &SubscriberReference::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountLevelInfo_descriptor_, &AccountLevelInfo::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    PrivacyInfo_descriptor_, &PrivacyInfo::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ParentalControlInfo_descriptor_, &ParentalControlInfo::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameLevelInfo_descriptor_, &GameLevelInfo::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameTimeInfo_descriptor_, &GameTimeInfo::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameTimeRemainingInfo_descriptor_, &GameTimeRemainingInfo::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameStatus_descriptor_, &GameStatus::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RAFInfo_descriptor_, &RAFInfo::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameSessionInfo_descriptor_, &GameSessionInfo::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameSessionUpdateInfo_descriptor_, &GameSessionUpdateInfo::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameSessionLocation_descriptor_, &GameSessionLocation::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    CAIS_descriptor_, &CAIS::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameAccountList_descriptor_, &GameAccountList::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountState_descriptor_, &AccountState::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountStateTagged_descriptor_, &AccountStateTagged::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameAccountState_descriptor_, &GameAccountState::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameAccountStateTagged_descriptor_, &GameAccountStateTagged::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AuthorizedData_descriptor_, &AuthorizedData::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_account_5ftypes_2eproto() {
+  delete AccountId::default_instance_;
+  delete AccountId_reflection_;
+  delete AccountLicense::default_instance_;
+  delete AccountLicense_reflection_;
+  delete AccountCredential::default_instance_;
+  delete AccountCredential_reflection_;
+  delete AccountBlob::default_instance_;
+  delete AccountBlob_reflection_;
+  delete AccountBlobList::default_instance_;
+  delete AccountBlobList_reflection_;
+  delete GameAccountHandle::default_instance_;
+  delete GameAccountHandle_reflection_;
+  delete GameAccountLink::default_instance_;
+  delete GameAccountLink_reflection_;
+  delete GameAccountBlob::default_instance_;
+  delete GameAccountBlob_reflection_;
+  delete GameAccountBlobList::default_instance_;
+  delete GameAccountBlobList_reflection_;
+  delete AccountReference::default_instance_;
+  delete AccountReference_reflection_;
+  delete Identity::default_instance_;
+  delete Identity_reflection_;
+  delete ProgramTag::default_instance_;
+  delete ProgramTag_reflection_;
+  delete RegionTag::default_instance_;
+  delete RegionTag_reflection_;
+  delete AccountFieldTags::default_instance_;
+  delete AccountFieldTags_reflection_;
+  delete GameAccountFieldTags::default_instance_;
+  delete GameAccountFieldTags_reflection_;
+  delete AccountFieldOptions::default_instance_;
+  delete AccountFieldOptions_reflection_;
+  delete GameAccountFieldOptions::default_instance_;
+  delete GameAccountFieldOptions_reflection_;
+  delete SubscriberReference::default_instance_;
+  delete SubscriberReference_reflection_;
+  delete AccountLevelInfo::default_instance_;
+  delete AccountLevelInfo_reflection_;
+  delete PrivacyInfo::default_instance_;
+  delete PrivacyInfo_reflection_;
+  delete ParentalControlInfo::default_instance_;
+  delete ParentalControlInfo_reflection_;
+  delete GameLevelInfo::default_instance_;
+  delete GameLevelInfo_reflection_;
+  delete GameTimeInfo::default_instance_;
+  delete GameTimeInfo_reflection_;
+  delete GameTimeRemainingInfo::default_instance_;
+  delete GameTimeRemainingInfo_reflection_;
+  delete GameStatus::default_instance_;
+  delete GameStatus_reflection_;
+  delete RAFInfo::default_instance_;
+  delete RAFInfo_reflection_;
+  delete GameSessionInfo::default_instance_;
+  delete GameSessionInfo_reflection_;
+  delete GameSessionUpdateInfo::default_instance_;
+  delete GameSessionUpdateInfo_reflection_;
+  delete GameSessionLocation::default_instance_;
+  delete GameSessionLocation_reflection_;
+  delete CAIS::default_instance_;
+  delete CAIS_reflection_;
+  delete GameAccountList::default_instance_;
+  delete GameAccountList_reflection_;
+  delete AccountState::default_instance_;
+  delete AccountState_reflection_;
+  delete AccountStateTagged::default_instance_;
+  delete AccountStateTagged_reflection_;
+  delete GameAccountState::default_instance_;
+  delete GameAccountState_reflection_;
+  delete GameAccountStateTagged::default_instance_;
+  delete GameAccountStateTagged_reflection_;
+  delete AuthorizedData::default_instance_;
+  delete AuthorizedData_reflection_;
+}
+
+void protobuf_AddDesc_account_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\023account_types.proto\022\027bgs.protocol.acco"
+    "unt.v1\032\022entity_types.proto\032\017rpc_types.pr"
+    "oto\"\027\n\tAccountId\022\n\n\002id\030\001 \002(\007\"-\n\016AccountL"
+    "icense\022\n\n\002id\030\001 \002(\r\022\017\n\007expires\030\002 \001(\004\"-\n\021A"
+    "ccountCredential\022\n\n\002id\030\001 \002(\r\022\014\n\004data\030\002 \001"
+    "(\014\"\237\005\n\013AccountBlob\022\n\n\002id\030\002 \002(\007\022\016\n\006region"
+    "\030\003 \002(\r\022\r\n\005email\030\004 \003(\t\022\r\n\005flags\030\005 \002(\004\022\026\n\016"
+    "secure_release\030\006 \001(\004\022\027\n\017whitelist_start\030"
+    "\007 \001(\004\022\025\n\rwhitelist_end\030\010 \001(\004\022\021\n\tfull_nam"
+    "e\030\n \002(\t\0229\n\010licenses\030\024 \003(\0132\'.bgs.protocol"
+    ".account.v1.AccountLicense\022\?\n\013credential"
+    "s\030\025 \003(\0132*.bgs.protocol.account.v1.Accoun"
+    "tCredential\022\?\n\raccount_links\030\026 \003(\0132(.bgs"
+    ".protocol.account.v1.GameAccountLink\022\022\n\n"
+    "battle_tag\030\027 \001(\t\022\030\n\020default_currency\030\031 \001"
+    "(\007\022\024\n\014legal_region\030\032 \001(\r\022\024\n\014legal_locale"
+    "\030\033 \001(\007\022\030\n\020cache_expiration\030\036 \002(\004\022K\n\025pare"
+    "ntal_control_info\030\037 \001(\0132,.bgs.protocol.a"
+    "ccount.v1.ParentalControlInfo\022\017\n\007country"
+    "\030  \001(\t\022\030\n\020preferred_region\030! \001(\r\022R\n\025iden"
+    "tity_check_status\030\" \001(\01623.bgs.protocol.a"
+    "ccount.v1.IdentityVerificationStatus\"E\n\017"
+    "AccountBlobList\0222\n\004blob\030\001 \003(\0132$.bgs.prot"
+    "ocol.account.v1.AccountBlob\"@\n\021GameAccou"
+    "ntHandle\022\n\n\002id\030\001 \002(\007\022\017\n\007program\030\002 \002(\007\022\016\n"
+    "\006region\030\003 \002(\r\"a\n\017GameAccountLink\022@\n\014game"
+    "_account\030\001 \002(\0132*.bgs.protocol.account.v1"
+    ".GameAccountHandle\022\014\n\004name\030\002 \002(\t\"\327\003\n\017Gam"
+    "eAccountBlob\022@\n\014game_account\030\001 \002(\0132*.bgs"
+    ".protocol.account.v1.GameAccountHandle\022\016"
+    "\n\004name\030\002 \001(\t:\000\022\034\n\021realm_permissions\030\003 \001("
+    "\r:\0010\022\016\n\006status\030\004 \002(\r\022\020\n\005flags\030\005 \001(\004:\0010\022\030"
+    "\n\rbilling_flags\030\006 \001(\r:\0010\022\030\n\020cache_expira"
+    "tion\030\007 \002(\004\022\037\n\027subscription_expiration\030\n "
+    "\001(\004\022\027\n\017units_remaining\030\013 \001(\r\022\031\n\021status_e"
+    "xpiration\030\014 \001(\004\022\021\n\tbox_level\030\r \001(\r\022\034\n\024bo"
+    "x_level_expiration\030\016 \001(\004\0229\n\010licenses\030\024 \003"
+    "(\0132\'.bgs.protocol.account.v1.AccountLice"
+    "nse\022\023\n\013raf_account\030\025 \001(\007\022\020\n\010raf_info\030\026 \001"
+    "(\014\022\026\n\016raf_expiration\030\027 \001(\004\"M\n\023GameAccoun"
+    "tBlobList\0226\n\004blob\030\001 \003(\0132(.bgs.protocol.a"
+    "ccount.v1.GameAccountBlob\"\220\001\n\020AccountRef"
+    "erence\022\n\n\002id\030\001 \001(\007\022\r\n\005email\030\002 \001(\t\022:\n\006han"
+    "dle\030\003 \001(\0132*.bgs.protocol.account.v1.Game"
+    "AccountHandle\022\022\n\nbattle_tag\030\004 \001(\t\022\021\n\006reg"
+    "ion\030\n \001(\r:\0010\"\253\001\n\010Identity\0223\n\007account\030\001 \001"
+    "(\0132\".bgs.protocol.account.v1.AccountId\022@"
+    "\n\014game_account\030\002 \001(\0132*.bgs.protocol.acco"
+    "unt.v1.GameAccountHandle\022(\n\007process\030\003 \001("
+    "\0132\027.bgs.protocol.ProcessId\"*\n\nProgramTag"
+    "\022\017\n\007program\030\001 \001(\007\022\013\n\003tag\030\002 \001(\007\"(\n\tRegion"
+    "Tag\022\016\n\006region\030\001 \001(\007\022\013\n\003tag\030\002 \001(\007\"\260\002\n\020Acc"
+    "ountFieldTags\022\036\n\026account_level_info_tag\030"
+    "\002 \001(\007\022\030\n\020privacy_info_tag\030\003 \001(\007\022!\n\031paren"
+    "tal_control_info_tag\030\004 \001(\007\022A\n\024game_level"
+    "_info_tags\030\007 \003(\0132#.bgs.protocol.account."
+    "v1.ProgramTag\022=\n\020game_status_tags\030\t \003(\0132"
+    "#.bgs.protocol.account.v1.ProgramTag\022=\n\021"
+    "game_account_tags\030\013 \003(\0132\".bgs.protocol.a"
+    "ccount.v1.RegionTag\"~\n\024GameAccountFieldT"
+    "ags\022\033\n\023game_level_info_tag\030\002 \001(\007\022\032\n\022game"
+    "_time_info_tag\030\003 \001(\007\022\027\n\017game_status_tag\030"
+    "\004 \001(\007\022\024\n\014raf_info_tag\030\005 \001(\007\"\343\001\n\023AccountF"
+    "ieldOptions\022\022\n\nall_fields\030\001 \001(\010\022 \n\030field"
+    "_account_level_info\030\002 \001(\010\022\032\n\022field_priva"
+    "cy_info\030\003 \001(\010\022#\n\033field_parental_control_"
+    "info\030\004 \001(\010\022\035\n\025field_game_level_info\030\006 \001("
+    "\010\022\031\n\021field_game_status\030\007 \001(\010\022\033\n\023field_ga"
+    "me_accounts\030\010 \001(\010\"\235\001\n\027GameAccountFieldOp"
+    "tions\022\022\n\nall_fields\030\001 \001(\010\022\035\n\025field_game_"
+    "level_info\030\002 \001(\010\022\034\n\024field_game_time_info"
+    "\030\003 \001(\010\022\031\n\021field_game_status\030\004 \001(\010\022\026\n\016fie"
+    "ld_raf_info\030\005 \001(\010\"\222\003\n\023SubscriberReferenc"
+    "e\022\024\n\tobject_id\030\001 \001(\004:\0010\022)\n\tentity_id\030\002 \001"
+    "(\0132\026.bgs.protocol.EntityId\022E\n\017account_op"
+    "tions\030\003 \001(\0132,.bgs.protocol.account.v1.Ac"
+    "countFieldOptions\022\?\n\014account_tags\030\004 \001(\0132"
+    ").bgs.protocol.account.v1.AccountFieldTa"
+    "gs\022N\n\024game_account_options\030\005 \001(\01320.bgs.p"
+    "rotocol.account.v1.GameAccountFieldOptio"
+    "ns\022H\n\021game_account_tags\030\006 \001(\0132-.bgs.prot"
+    "ocol.account.v1.GameAccountFieldTags\022\030\n\r"
+    "subscriber_id\030\007 \001(\004:\0010\"\334\002\n\020AccountLevelI"
+    "nfo\0229\n\010licenses\030\003 \003(\0132\'.bgs.protocol.acc"
+    "ount.v1.AccountLicense\022\030\n\020default_curren"
+    "cy\030\004 \001(\007\022\017\n\007country\030\005 \001(\t\022\030\n\020preferred_r"
+    "egion\030\006 \001(\r\022\021\n\tfull_name\030\007 \001(\t\022\022\n\nbattle"
+    "_tag\030\010 \001(\t\022\r\n\005muted\030\t \001(\010\022\025\n\rmanual_revi"
+    "ew\030\n \001(\010\022\030\n\020account_paid_any\030\013 \001(\010\022R\n\025id"
+    "entity_check_status\030\014 \001(\01623.bgs.protocol"
+    ".account.v1.IdentityVerificationStatus\022\r"
+    "\n\005email\030\r \001(\t\"\246\002\n\013PrivacyInfo\022\024\n\014is_usin"
+    "g_rid\030\003 \001(\010\022+\n#is_real_id_visible_for_vi"
+    "ew_friends\030\004 \001(\010\022$\n\034is_hidden_from_frien"
+    "d_finder\030\005 \001(\010\022`\n\021game_info_privacy\030\006 \001("
+    "\01624.bgs.protocol.account.v1.PrivacyInfo."
+    "GameInfoPrivacy:\017PRIVACY_FRIENDS\"L\n\017Game"
+    "InfoPrivacy\022\016\n\nPRIVACY_ME\020\000\022\023\n\017PRIVACY_F"
+    "RIENDS\020\001\022\024\n\020PRIVACY_EVERYONE\020\002\"\244\001\n\023Paren"
+    "talControlInfo\022\020\n\010timezone\030\003 \001(\t\022\027\n\017minu"
+    "tes_per_day\030\004 \001(\r\022\030\n\020minutes_per_week\030\005 "
+    "\001(\r\022\031\n\021can_receive_voice\030\006 \001(\010\022\026\n\016can_se"
+    "nd_voice\030\007 \001(\010\022\025\n\rplay_schedule\030\010 \003(\010\"\323\001"
+    "\n\rGameLevelInfo\022\020\n\010is_trial\030\004 \001(\010\022\023\n\013is_"
+    "lifetime\030\005 \001(\010\022\025\n\ris_restricted\030\006 \001(\010\022\017\n"
+    "\007is_beta\030\007 \001(\010\022\014\n\004name\030\010 \001(\t\022\017\n\007program\030"
+    "\t \001(\007\0229\n\010licenses\030\n \003(\0132\'.bgs.protocol.a"
+    "ccount.v1.AccountLicense\022\031\n\021realm_permis"
+    "sions\030\013 \001(\r\"\205\001\n\014GameTimeInfo\022\036\n\026is_unlim"
+    "ited_play_time\030\003 \001(\010\022\031\n\021play_time_expire"
+    "s\030\005 \001(\004\022\027\n\017is_subscription\030\006 \001(\010\022!\n\031is_r"
+    "ecurring_subscription\030\007 \001(\010\"\255\001\n\025GameTime"
+    "RemainingInfo\022\031\n\021minutes_remaining\030\001 \001(\r"
+    "\022(\n parental_daily_minutes_remaining\030\002 \001"
+    "(\r\022)\n!parental_weekly_minutes_remaining\030"
+    "\003 \001(\r\022$\n\034seconds_remaining_until_kick\030\004 "
+    "\001(\r\"\220\001\n\nGameStatus\022\024\n\014is_suspended\030\004 \001(\010"
+    "\022\021\n\tis_banned\030\005 \001(\010\022\032\n\022suspension_expire"
+    "s\030\006 \001(\004\022\017\n\007program\030\007 \001(\007\022\021\n\tis_locked\030\010 "
+    "\001(\010\022\031\n\021is_bam_unlockable\030\t \001(\010\"\033\n\007RAFInf"
+    "o\022\020\n\010raf_info\030\001 \001(\014\"\321\001\n\017GameSessionInfo\022"
+    "\026\n\nstart_time\030\003 \001(\rB\002\030\001\022>\n\010location\030\004 \001("
+    "\0132,.bgs.protocol.account.v1.GameSessionL"
+    "ocation\022\026\n\016has_benefactor\030\005 \001(\010\022\024\n\014is_us"
+    "ing_igr\030\006 \001(\010\022 \n\030parental_controls_activ"
+    "e\030\007 \001(\010\022\026\n\016start_time_sec\030\010 \001(\004\"D\n\025GameS"
+    "essionUpdateInfo\022+\n\004cais\030\010 \001(\0132\035.bgs.pro"
+    "tocol.account.v1.CAIS\"H\n\023GameSessionLoca"
+    "tion\022\022\n\nip_address\030\001 \001(\t\022\017\n\007country\030\002 \001("
+    "\r\022\014\n\004city\030\003 \001(\t\"O\n\004CAIS\022\026\n\016played_minute"
+    "s\030\001 \001(\r\022\026\n\016rested_minutes\030\002 \001(\r\022\027\n\017last_"
+    "heard_time\030\003 \001(\004\"]\n\017GameAccountList\022\016\n\006r"
+    "egion\030\003 \001(\r\022:\n\006handle\030\004 \003(\0132*.bgs.protoc"
+    "ol.account.v1.GameAccountHandle\"\232\003\n\014Acco"
+    "untState\022E\n\022account_level_info\030\001 \001(\0132).b"
+    "gs.protocol.account.v1.AccountLevelInfo\022"
+    ":\n\014privacy_info\030\002 \001(\0132$.bgs.protocol.acc"
+    "ount.v1.PrivacyInfo\022K\n\025parental_control_"
+    "info\030\003 \001(\0132,.bgs.protocol.account.v1.Par"
+    "entalControlInfo\022\?\n\017game_level_info\030\005 \003("
+    "\0132&.bgs.protocol.account.v1.GameLevelInf"
+    "o\0228\n\013game_status\030\006 \003(\0132#.bgs.protocol.ac"
+    "count.v1.GameStatus\022\?\n\rgame_accounts\030\007 \003"
+    "(\0132(.bgs.protocol.account.v1.GameAccount"
+    "List\"\223\001\n\022AccountStateTagged\022<\n\raccount_s"
+    "tate\030\001 \001(\0132%.bgs.protocol.account.v1.Acc"
+    "ountState\022\?\n\014account_tags\030\002 \001(\0132).bgs.pr"
+    "otocol.account.v1.AccountFieldTags\"\200\002\n\020G"
+    "ameAccountState\022\?\n\017game_level_info\030\001 \001(\013"
+    "2&.bgs.protocol.account.v1.GameLevelInfo"
+    "\022=\n\016game_time_info\030\002 \001(\0132%.bgs.protocol."
+    "account.v1.GameTimeInfo\0228\n\013game_status\030\003"
+    " \001(\0132#.bgs.protocol.account.v1.GameStatu"
+    "s\0222\n\010raf_info\030\004 \001(\0132 .bgs.protocol.accou"
+    "nt.v1.RAFInfo\"\251\001\n\026GameAccountStateTagged"
+    "\022E\n\022game_account_state\030\001 \001(\0132).bgs.proto"
+    "col.account.v1.GameAccountState\022H\n\021game_"
+    "account_tags\030\002 \001(\0132-.bgs.protocol.accoun"
+    "t.v1.GameAccountFieldTags\"/\n\016AuthorizedD"
+    "ata\022\014\n\004data\030\001 \001(\t\022\017\n\007license\030\002 \003(\r*\216\001\n\032I"
+    "dentityVerificationStatus\022\021\n\rIDENT_NO_DA"
+    "TA\020\000\022\021\n\rIDENT_PENDING\020\001\022\020\n\014IDENT_FAILED\020"
+    "\004\022\021\n\rIDENT_SUCCESS\020\005\022\022\n\016IDENT_SUCC_MNL\020\006"
+    "\022\021\n\rIDENT_UNKNOWN\020\007B\002H\001", 6543);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "account_types.proto", &protobuf_RegisterTypes);
+  AccountId::default_instance_ = new AccountId();
+  AccountLicense::default_instance_ = new AccountLicense();
+  AccountCredential::default_instance_ = new AccountCredential();
+  AccountBlob::default_instance_ = new AccountBlob();
+  AccountBlobList::default_instance_ = new AccountBlobList();
+  GameAccountHandle::default_instance_ = new GameAccountHandle();
+  GameAccountLink::default_instance_ = new GameAccountLink();
+  GameAccountBlob::default_instance_ = new GameAccountBlob();
+  GameAccountBlobList::default_instance_ = new GameAccountBlobList();
+  AccountReference::default_instance_ = new AccountReference();
+  Identity::default_instance_ = new Identity();
+  ProgramTag::default_instance_ = new ProgramTag();
+  RegionTag::default_instance_ = new RegionTag();
+  AccountFieldTags::default_instance_ = new AccountFieldTags();
+  GameAccountFieldTags::default_instance_ = new GameAccountFieldTags();
+  AccountFieldOptions::default_instance_ = new AccountFieldOptions();
+  GameAccountFieldOptions::default_instance_ = new GameAccountFieldOptions();
+  SubscriberReference::default_instance_ = new SubscriberReference();
+  AccountLevelInfo::default_instance_ = new AccountLevelInfo();
+  PrivacyInfo::default_instance_ = new PrivacyInfo();
+  ParentalControlInfo::default_instance_ = new ParentalControlInfo();
+  GameLevelInfo::default_instance_ = new GameLevelInfo();
+  GameTimeInfo::default_instance_ = new GameTimeInfo();
+  GameTimeRemainingInfo::default_instance_ = new GameTimeRemainingInfo();
+  GameStatus::default_instance_ = new GameStatus();
+  RAFInfo::default_instance_ = new RAFInfo();
+  GameSessionInfo::default_instance_ = new GameSessionInfo();
+  GameSessionUpdateInfo::default_instance_ = new GameSessionUpdateInfo();
+  GameSessionLocation::default_instance_ = new GameSessionLocation();
+  CAIS::default_instance_ = new CAIS();
+  GameAccountList::default_instance_ = new GameAccountList();
+  AccountState::default_instance_ = new AccountState();
+  AccountStateTagged::default_instance_ = new AccountStateTagged();
+  GameAccountState::default_instance_ = new GameAccountState();
+  GameAccountStateTagged::default_instance_ = new GameAccountStateTagged();
+  AuthorizedData::default_instance_ = new AuthorizedData();
+  AccountId::default_instance_->InitAsDefaultInstance();
+  AccountLicense::default_instance_->InitAsDefaultInstance();
+  AccountCredential::default_instance_->InitAsDefaultInstance();
+  AccountBlob::default_instance_->InitAsDefaultInstance();
+  AccountBlobList::default_instance_->InitAsDefaultInstance();
+  GameAccountHandle::default_instance_->InitAsDefaultInstance();
+  GameAccountLink::default_instance_->InitAsDefaultInstance();
+  GameAccountBlob::default_instance_->InitAsDefaultInstance();
+  GameAccountBlobList::default_instance_->InitAsDefaultInstance();
+  AccountReference::default_instance_->InitAsDefaultInstance();
+  Identity::default_instance_->InitAsDefaultInstance();
+  ProgramTag::default_instance_->InitAsDefaultInstance();
+  RegionTag::default_instance_->InitAsDefaultInstance();
+  AccountFieldTags::default_instance_->InitAsDefaultInstance();
+  GameAccountFieldTags::default_instance_->InitAsDefaultInstance();
+  AccountFieldOptions::default_instance_->InitAsDefaultInstance();
+  GameAccountFieldOptions::default_instance_->InitAsDefaultInstance();
+  SubscriberReference::default_instance_->InitAsDefaultInstance();
+  AccountLevelInfo::default_instance_->InitAsDefaultInstance();
+  PrivacyInfo::default_instance_->InitAsDefaultInstance();
+  ParentalControlInfo::default_instance_->InitAsDefaultInstance();
+  GameLevelInfo::default_instance_->InitAsDefaultInstance();
+  GameTimeInfo::default_instance_->InitAsDefaultInstance();
+  GameTimeRemainingInfo::default_instance_->InitAsDefaultInstance();
+  GameStatus::default_instance_->InitAsDefaultInstance();
+  RAFInfo::default_instance_->InitAsDefaultInstance();
+  GameSessionInfo::default_instance_->InitAsDefaultInstance();
+  GameSessionUpdateInfo::default_instance_->InitAsDefaultInstance();
+  GameSessionLocation::default_instance_->InitAsDefaultInstance();
+  CAIS::default_instance_->InitAsDefaultInstance();
+  GameAccountList::default_instance_->InitAsDefaultInstance();
+  AccountState::default_instance_->InitAsDefaultInstance();
+  AccountStateTagged::default_instance_->InitAsDefaultInstance();
+  GameAccountState::default_instance_->InitAsDefaultInstance();
+  GameAccountStateTagged::default_instance_->InitAsDefaultInstance();
+  AuthorizedData::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_account_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_account_5ftypes_2eproto {
+  StaticDescriptorInitializer_account_5ftypes_2eproto() {
+    protobuf_AddDesc_account_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_account_5ftypes_2eproto_;
+const ::google::protobuf::EnumDescriptor* IdentityVerificationStatus_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return IdentityVerificationStatus_descriptor_;
+}
+bool IdentityVerificationStatus_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 4:
+    case 5:
+    case 6:
+    case 7:
+      return true;
+    default:
+      return false;
+  }
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountId::kIdFieldNumber;
+#endif  // !_MSC_VER
+
+AccountId::AccountId()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountId)
+}
+
+void AccountId::InitAsDefaultInstance() {
+}
+
+AccountId::AccountId(const AccountId& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountId)
+}
+
+void AccountId::SharedCtor() {
+  _cached_size_ = 0;
+  id_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountId::~AccountId() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountId)
+  SharedDtor();
+}
+
+void AccountId::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void AccountId::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountId::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountId_descriptor_;
+}
+
+const AccountId& AccountId::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+AccountId* AccountId::default_instance_ = NULL;
+
+AccountId* AccountId::New() const {
+  return new AccountId;
+}
+
+void AccountId::Clear() {
+  id_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountId::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountId)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required fixed32 id = 1;
+      case 1: {
+        if (tag == 13) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountId)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountId)
+  return false;
+#undef DO_
+}
+
+void AccountId::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountId)
+  // required fixed32 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountId)
+}
+
+::google::protobuf::uint8* AccountId::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountId)
+  // required fixed32 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountId)
+  return target;
+}
+
+int AccountId::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required fixed32 id = 1;
+    if (has_id()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountId::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountId* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountId*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountId::MergeFrom(const AccountId& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountId::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountId::CopyFrom(const AccountId& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountId::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  return true;
+}
+
+void AccountId::Swap(AccountId* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountId::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountId_descriptor_;
+  metadata.reflection = AccountId_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountLicense::kIdFieldNumber;
+const int AccountLicense::kExpiresFieldNumber;
+#endif  // !_MSC_VER
+
+AccountLicense::AccountLicense()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountLicense)
+}
+
+void AccountLicense::InitAsDefaultInstance() {
+}
+
+AccountLicense::AccountLicense(const AccountLicense& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountLicense)
+}
+
+void AccountLicense::SharedCtor() {
+  _cached_size_ = 0;
+  id_ = 0u;
+  expires_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountLicense::~AccountLicense() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountLicense)
+  SharedDtor();
+}
+
+void AccountLicense::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void AccountLicense::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountLicense::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountLicense_descriptor_;
+}
+
+const AccountLicense& AccountLicense::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+AccountLicense* AccountLicense::default_instance_ = NULL;
+
+AccountLicense* AccountLicense::New() const {
+  return new AccountLicense;
+}
+
+void AccountLicense::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<AccountLicense*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(expires_, id_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountLicense::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountLicense)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required uint32 id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_expires;
+        break;
+      }
+
+      // optional uint64 expires = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_expires:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &expires_)));
+          set_has_expires();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountLicense)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountLicense)
+  return false;
+#undef DO_
+}
+
+void AccountLicense::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountLicense)
+  // required uint32 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output);
+  }
+
+  // optional uint64 expires = 2;
+  if (has_expires()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->expires(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountLicense)
+}
+
+::google::protobuf::uint8* AccountLicense::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountLicense)
+  // required uint32 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target);
+  }
+
+  // optional uint64 expires = 2;
+  if (has_expires()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->expires(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountLicense)
+  return target;
+}
+
+int AccountLicense::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->id());
+    }
+
+    // optional uint64 expires = 2;
+    if (has_expires()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->expires());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountLicense::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountLicense* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountLicense*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountLicense::MergeFrom(const AccountLicense& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_expires()) {
+      set_expires(from.expires());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountLicense::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountLicense::CopyFrom(const AccountLicense& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountLicense::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  return true;
+}
+
+void AccountLicense::Swap(AccountLicense* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(expires_, other->expires_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountLicense::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountLicense_descriptor_;
+  metadata.reflection = AccountLicense_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountCredential::kIdFieldNumber;
+const int AccountCredential::kDataFieldNumber;
+#endif  // !_MSC_VER
+
+AccountCredential::AccountCredential()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountCredential)
+}
+
+void AccountCredential::InitAsDefaultInstance() {
+}
+
+AccountCredential::AccountCredential(const AccountCredential& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountCredential)
+}
+
+void AccountCredential::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = 0u;
+  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountCredential::~AccountCredential() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountCredential)
+  SharedDtor();
+}
+
+void AccountCredential::SharedDtor() {
+  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete data_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void AccountCredential::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountCredential::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountCredential_descriptor_;
+}
+
+const AccountCredential& AccountCredential::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+AccountCredential* AccountCredential::default_instance_ = NULL;
+
+AccountCredential* AccountCredential::New() const {
+  return new AccountCredential;
+}
+
+void AccountCredential::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    id_ = 0u;
+    if (has_data()) {
+      if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        data_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountCredential::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountCredential)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required uint32 id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_data;
+        break;
+      }
+
+      // optional bytes data = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_data:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_data()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountCredential)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountCredential)
+  return false;
+#undef DO_
+}
+
+void AccountCredential::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountCredential)
+  // required uint32 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output);
+  }
+
+  // optional bytes data = 2;
+  if (has_data()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->data(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountCredential)
+}
+
+::google::protobuf::uint8* AccountCredential::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountCredential)
+  // required uint32 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target);
+  }
+
+  // optional bytes data = 2;
+  if (has_data()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        2, this->data(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountCredential)
+  return target;
+}
+
+int AccountCredential::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->id());
+    }
+
+    // optional bytes data = 2;
+    if (has_data()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->data());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountCredential::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountCredential* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountCredential*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountCredential::MergeFrom(const AccountCredential& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_data()) {
+      set_data(from.data());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountCredential::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountCredential::CopyFrom(const AccountCredential& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountCredential::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  return true;
+}
+
+void AccountCredential::Swap(AccountCredential* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(data_, other->data_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountCredential::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountCredential_descriptor_;
+  metadata.reflection = AccountCredential_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountBlob::kIdFieldNumber;
+const int AccountBlob::kRegionFieldNumber;
+const int AccountBlob::kEmailFieldNumber;
+const int AccountBlob::kFlagsFieldNumber;
+const int AccountBlob::kSecureReleaseFieldNumber;
+const int AccountBlob::kWhitelistStartFieldNumber;
+const int AccountBlob::kWhitelistEndFieldNumber;
+const int AccountBlob::kFullNameFieldNumber;
+const int AccountBlob::kLicensesFieldNumber;
+const int AccountBlob::kCredentialsFieldNumber;
+const int AccountBlob::kAccountLinksFieldNumber;
+const int AccountBlob::kBattleTagFieldNumber;
+const int AccountBlob::kDefaultCurrencyFieldNumber;
+const int AccountBlob::kLegalRegionFieldNumber;
+const int AccountBlob::kLegalLocaleFieldNumber;
+const int AccountBlob::kCacheExpirationFieldNumber;
+const int AccountBlob::kParentalControlInfoFieldNumber;
+const int AccountBlob::kCountryFieldNumber;
+const int AccountBlob::kPreferredRegionFieldNumber;
+const int AccountBlob::kIdentityCheckStatusFieldNumber;
+#endif  // !_MSC_VER
+
+AccountBlob::AccountBlob()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountBlob)
+}
+
+void AccountBlob::InitAsDefaultInstance() {
+  parental_control_info_ = const_cast< ::bgs::protocol::account::v1::ParentalControlInfo*>(&::bgs::protocol::account::v1::ParentalControlInfo::default_instance());
+}
+
+AccountBlob::AccountBlob(const AccountBlob& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountBlob)
+}
+
+void AccountBlob::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = 0u;
+  region_ = 0u;
+  flags_ = GOOGLE_ULONGLONG(0);
+  secure_release_ = GOOGLE_ULONGLONG(0);
+  whitelist_start_ = GOOGLE_ULONGLONG(0);
+  whitelist_end_ = GOOGLE_ULONGLONG(0);
+  full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  default_currency_ = 0u;
+  legal_region_ = 0u;
+  legal_locale_ = 0u;
+  cache_expiration_ = GOOGLE_ULONGLONG(0);
+  parental_control_info_ = NULL;
+  country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  preferred_region_ = 0u;
+  identity_check_status_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountBlob::~AccountBlob() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountBlob)
+  SharedDtor();
+}
+
+void AccountBlob::SharedDtor() {
+  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete full_name_;
+  }
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete battle_tag_;
+  }
+  if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete country_;
+  }
+  if (this != default_instance_) {
+    delete parental_control_info_;
+  }
+}
+
+void AccountBlob::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountBlob::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountBlob_descriptor_;
+}
+
+const AccountBlob& AccountBlob::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+AccountBlob* AccountBlob::default_instance_ = NULL;
+
+AccountBlob* AccountBlob::New() const {
+  return new AccountBlob;
+}
+
+void AccountBlob::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<AccountBlob*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 251) {
+    ZR_(id_, region_);
+    ZR_(flags_, whitelist_end_);
+    if (has_full_name()) {
+      if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        full_name_->clear();
+      }
+    }
+  }
+  if (_has_bits_[8 / 32] & 63488) {
+    ZR_(default_currency_, cache_expiration_);
+    if (has_battle_tag()) {
+      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        battle_tag_->clear();
+      }
+    }
+    legal_locale_ = 0u;
+  }
+  if (_has_bits_[16 / 32] & 983040) {
+    if (has_parental_control_info()) {
+      if (parental_control_info_ != NULL) parental_control_info_->::bgs::protocol::account::v1::ParentalControlInfo::Clear();
+    }
+    if (has_country()) {
+      if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        country_->clear();
+      }
+    }
+    preferred_region_ = 0u;
+    identity_check_status_ = 0;
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  email_.Clear();
+  licenses_.Clear();
+  credentials_.Clear();
+  account_links_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountBlob::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountBlob)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required fixed32 id = 2;
+      case 2: {
+        if (tag == 21) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_region;
+        break;
+      }
+
+      // required uint32 region = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_region:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &region_)));
+          set_has_region();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_email;
+        break;
+      }
+
+      // repeated string email = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_email:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_email()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->email(this->email_size() - 1).data(),
+            this->email(this->email_size() - 1).length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "email");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_email;
+        if (input->ExpectTag(40)) goto parse_flags;
+        break;
+      }
+
+      // required uint64 flags = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_flags:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &flags_)));
+          set_has_flags();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_secure_release;
+        break;
+      }
+
+      // optional uint64 secure_release = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_secure_release:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &secure_release_)));
+          set_has_secure_release();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_whitelist_start;
+        break;
+      }
+
+      // optional uint64 whitelist_start = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_whitelist_start:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &whitelist_start_)));
+          set_has_whitelist_start();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_whitelist_end;
+        break;
+      }
+
+      // optional uint64 whitelist_end = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_whitelist_end:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &whitelist_end_)));
+          set_has_whitelist_end();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_full_name;
+        break;
+      }
+
+      // required string full_name = 10;
+      case 10: {
+        if (tag == 82) {
+         parse_full_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_full_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->full_name().data(), this->full_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "full_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(162)) goto parse_licenses;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
+      case 20: {
+        if (tag == 162) {
+         parse_licenses:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_licenses()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(162)) goto parse_licenses;
+        if (input->ExpectTag(170)) goto parse_credentials;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.AccountCredential credentials = 21;
+      case 21: {
+        if (tag == 170) {
+         parse_credentials:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_credentials()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(170)) goto parse_credentials;
+        if (input->ExpectTag(178)) goto parse_account_links;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22;
+      case 22: {
+        if (tag == 178) {
+         parse_account_links:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_account_links()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(178)) goto parse_account_links;
+        if (input->ExpectTag(186)) goto parse_battle_tag;
+        break;
+      }
+
+      // optional string battle_tag = 23;
+      case 23: {
+        if (tag == 186) {
+         parse_battle_tag:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_battle_tag()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->battle_tag().data(), this->battle_tag().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "battle_tag");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(205)) goto parse_default_currency;
+        break;
+      }
+
+      // optional fixed32 default_currency = 25;
+      case 25: {
+        if (tag == 205) {
+         parse_default_currency:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &default_currency_)));
+          set_has_default_currency();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(208)) goto parse_legal_region;
+        break;
+      }
+
+      // optional uint32 legal_region = 26;
+      case 26: {
+        if (tag == 208) {
+         parse_legal_region:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &legal_region_)));
+          set_has_legal_region();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(221)) goto parse_legal_locale;
+        break;
+      }
+
+      // optional fixed32 legal_locale = 27;
+      case 27: {
+        if (tag == 221) {
+         parse_legal_locale:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &legal_locale_)));
+          set_has_legal_locale();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(240)) goto parse_cache_expiration;
+        break;
+      }
+
+      // required uint64 cache_expiration = 30;
+      case 30: {
+        if (tag == 240) {
+         parse_cache_expiration:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &cache_expiration_)));
+          set_has_cache_expiration();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(250)) goto parse_parental_control_info;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31;
+      case 31: {
+        if (tag == 250) {
+         parse_parental_control_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_parental_control_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(258)) goto parse_country;
+        break;
+      }
+
+      // optional string country = 32;
+      case 32: {
+        if (tag == 258) {
+         parse_country:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_country()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->country().data(), this->country().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "country");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(264)) goto parse_preferred_region;
+        break;
+      }
+
+      // optional uint32 preferred_region = 33;
+      case 33: {
+        if (tag == 264) {
+         parse_preferred_region:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &preferred_region_)));
+          set_has_preferred_region();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(272)) goto parse_identity_check_status;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34;
+      case 34: {
+        if (tag == 272) {
+         parse_identity_check_status:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::account::v1::IdentityVerificationStatus_IsValid(value)) {
+            set_identity_check_status(static_cast< ::bgs::protocol::account::v1::IdentityVerificationStatus >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(34, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountBlob)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountBlob)
+  return false;
+#undef DO_
+}
+
+void AccountBlob::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountBlob)
+  // required fixed32 id = 2;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->id(), output);
+  }
+
+  // required uint32 region = 3;
+  if (has_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->region(), output);
+  }
+
+  // repeated string email = 4;
+  for (int i = 0; i < this->email_size(); i++) {
+  ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+    this->email(i).data(), this->email(i).length(),
+    ::google::protobuf::internal::WireFormat::SERIALIZE,
+    "email");
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      4, this->email(i), output);
+  }
+
+  // required uint64 flags = 5;
+  if (has_flags()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->flags(), output);
+  }
+
+  // optional uint64 secure_release = 6;
+  if (has_secure_release()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(6, this->secure_release(), output);
+  }
+
+  // optional uint64 whitelist_start = 7;
+  if (has_whitelist_start()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(7, this->whitelist_start(), output);
+  }
+
+  // optional uint64 whitelist_end = 8;
+  if (has_whitelist_end()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->whitelist_end(), output);
+  }
+
+  // required string full_name = 10;
+  if (has_full_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->full_name().data(), this->full_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "full_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      10, this->full_name(), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
+  for (int i = 0; i < this->licenses_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      20, this->licenses(i), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountCredential credentials = 21;
+  for (int i = 0; i < this->credentials_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      21, this->credentials(i), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22;
+  for (int i = 0; i < this->account_links_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      22, this->account_links(i), output);
+  }
+
+  // optional string battle_tag = 23;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      23, this->battle_tag(), output);
+  }
+
+  // optional fixed32 default_currency = 25;
+  if (has_default_currency()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(25, this->default_currency(), output);
+  }
+
+  // optional uint32 legal_region = 26;
+  if (has_legal_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(26, this->legal_region(), output);
+  }
+
+  // optional fixed32 legal_locale = 27;
+  if (has_legal_locale()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(27, this->legal_locale(), output);
+  }
+
+  // required uint64 cache_expiration = 30;
+  if (has_cache_expiration()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(30, this->cache_expiration(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31;
+  if (has_parental_control_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      31, this->parental_control_info(), output);
+  }
+
+  // optional string country = 32;
+  if (has_country()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->country().data(), this->country().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "country");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      32, this->country(), output);
+  }
+
+  // optional uint32 preferred_region = 33;
+  if (has_preferred_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(33, this->preferred_region(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34;
+  if (has_identity_check_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      34, this->identity_check_status(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountBlob)
+}
+
+::google::protobuf::uint8* AccountBlob::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountBlob)
+  // required fixed32 id = 2;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->id(), target);
+  }
+
+  // required uint32 region = 3;
+  if (has_region()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->region(), target);
+  }
+
+  // repeated string email = 4;
+  for (int i = 0; i < this->email_size(); i++) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->email(i).data(), this->email(i).length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "email");
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteStringToArray(4, this->email(i), target);
+  }
+
+  // required uint64 flags = 5;
+  if (has_flags()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->flags(), target);
+  }
+
+  // optional uint64 secure_release = 6;
+  if (has_secure_release()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(6, this->secure_release(), target);
+  }
+
+  // optional uint64 whitelist_start = 7;
+  if (has_whitelist_start()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(7, this->whitelist_start(), target);
+  }
+
+  // optional uint64 whitelist_end = 8;
+  if (has_whitelist_end()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->whitelist_end(), target);
+  }
+
+  // required string full_name = 10;
+  if (has_full_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->full_name().data(), this->full_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "full_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        10, this->full_name(), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
+  for (int i = 0; i < this->licenses_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        20, this->licenses(i), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountCredential credentials = 21;
+  for (int i = 0; i < this->credentials_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        21, this->credentials(i), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22;
+  for (int i = 0; i < this->account_links_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        22, this->account_links(i), target);
+  }
+
+  // optional string battle_tag = 23;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        23, this->battle_tag(), target);
+  }
+
+  // optional fixed32 default_currency = 25;
+  if (has_default_currency()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(25, this->default_currency(), target);
+  }
+
+  // optional uint32 legal_region = 26;
+  if (has_legal_region()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(26, this->legal_region(), target);
+  }
+
+  // optional fixed32 legal_locale = 27;
+  if (has_legal_locale()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(27, this->legal_locale(), target);
+  }
+
+  // required uint64 cache_expiration = 30;
+  if (has_cache_expiration()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(30, this->cache_expiration(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31;
+  if (has_parental_control_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        31, this->parental_control_info(), target);
+  }
+
+  // optional string country = 32;
+  if (has_country()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->country().data(), this->country().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "country");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        32, this->country(), target);
+  }
+
+  // optional uint32 preferred_region = 33;
+  if (has_preferred_region()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(33, this->preferred_region(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34;
+  if (has_identity_check_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      34, this->identity_check_status(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountBlob)
+  return target;
+}
+
+int AccountBlob::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required fixed32 id = 2;
+    if (has_id()) {
+      total_size += 1 + 4;
+    }
+
+    // required uint32 region = 3;
+    if (has_region()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->region());
+    }
+
+    // required uint64 flags = 5;
+    if (has_flags()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->flags());
+    }
+
+    // optional uint64 secure_release = 6;
+    if (has_secure_release()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->secure_release());
+    }
+
+    // optional uint64 whitelist_start = 7;
+    if (has_whitelist_start()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->whitelist_start());
+    }
+
+    // optional uint64 whitelist_end = 8;
+    if (has_whitelist_end()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->whitelist_end());
+    }
+
+    // required string full_name = 10;
+    if (has_full_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->full_name());
+    }
+
+  }
+  if (_has_bits_[11 / 32] & (0xffu << (11 % 32))) {
+    // optional string battle_tag = 23;
+    if (has_battle_tag()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->battle_tag());
+    }
+
+    // optional fixed32 default_currency = 25;
+    if (has_default_currency()) {
+      total_size += 2 + 4;
+    }
+
+    // optional uint32 legal_region = 26;
+    if (has_legal_region()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->legal_region());
+    }
+
+    // optional fixed32 legal_locale = 27;
+    if (has_legal_locale()) {
+      total_size += 2 + 4;
+    }
+
+    // required uint64 cache_expiration = 30;
+    if (has_cache_expiration()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->cache_expiration());
+    }
+
+  }
+  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
+    // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31;
+    if (has_parental_control_info()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->parental_control_info());
+    }
+
+    // optional string country = 32;
+    if (has_country()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->country());
+    }
+
+    // optional uint32 preferred_region = 33;
+    if (has_preferred_region()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->preferred_region());
+    }
+
+    // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34;
+    if (has_identity_check_status()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->identity_check_status());
+    }
+
+  }
+  // repeated string email = 4;
+  total_size += 1 * this->email_size();
+  for (int i = 0; i < this->email_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->email(i));
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
+  total_size += 2 * this->licenses_size();
+  for (int i = 0; i < this->licenses_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->licenses(i));
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountCredential credentials = 21;
+  total_size += 2 * this->credentials_size();
+  for (int i = 0; i < this->credentials_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->credentials(i));
+  }
+
+  // repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22;
+  total_size += 2 * this->account_links_size();
+  for (int i = 0; i < this->account_links_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->account_links(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountBlob::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountBlob* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountBlob*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountBlob::MergeFrom(const AccountBlob& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  email_.MergeFrom(from.email_);
+  licenses_.MergeFrom(from.licenses_);
+  credentials_.MergeFrom(from.credentials_);
+  account_links_.MergeFrom(from.account_links_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_region()) {
+      set_region(from.region());
+    }
+    if (from.has_flags()) {
+      set_flags(from.flags());
+    }
+    if (from.has_secure_release()) {
+      set_secure_release(from.secure_release());
+    }
+    if (from.has_whitelist_start()) {
+      set_whitelist_start(from.whitelist_start());
+    }
+    if (from.has_whitelist_end()) {
+      set_whitelist_end(from.whitelist_end());
+    }
+    if (from.has_full_name()) {
+      set_full_name(from.full_name());
+    }
+  }
+  if (from._has_bits_[11 / 32] & (0xffu << (11 % 32))) {
+    if (from.has_battle_tag()) {
+      set_battle_tag(from.battle_tag());
+    }
+    if (from.has_default_currency()) {
+      set_default_currency(from.default_currency());
+    }
+    if (from.has_legal_region()) {
+      set_legal_region(from.legal_region());
+    }
+    if (from.has_legal_locale()) {
+      set_legal_locale(from.legal_locale());
+    }
+    if (from.has_cache_expiration()) {
+      set_cache_expiration(from.cache_expiration());
+    }
+  }
+  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
+    if (from.has_parental_control_info()) {
+      mutable_parental_control_info()->::bgs::protocol::account::v1::ParentalControlInfo::MergeFrom(from.parental_control_info());
+    }
+    if (from.has_country()) {
+      set_country(from.country());
+    }
+    if (from.has_preferred_region()) {
+      set_preferred_region(from.preferred_region());
+    }
+    if (from.has_identity_check_status()) {
+      set_identity_check_status(from.identity_check_status());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountBlob::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountBlob::CopyFrom(const AccountBlob& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountBlob::IsInitialized() const {
+  if ((_has_bits_[0] & 0x0000808b) != 0x0000808b) return false;
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->licenses())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->credentials())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->account_links())) return false;
+  return true;
+}
+
+void AccountBlob::Swap(AccountBlob* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(region_, other->region_);
+    email_.Swap(&other->email_);
+    std::swap(flags_, other->flags_);
+    std::swap(secure_release_, other->secure_release_);
+    std::swap(whitelist_start_, other->whitelist_start_);
+    std::swap(whitelist_end_, other->whitelist_end_);
+    std::swap(full_name_, other->full_name_);
+    licenses_.Swap(&other->licenses_);
+    credentials_.Swap(&other->credentials_);
+    account_links_.Swap(&other->account_links_);
+    std::swap(battle_tag_, other->battle_tag_);
+    std::swap(default_currency_, other->default_currency_);
+    std::swap(legal_region_, other->legal_region_);
+    std::swap(legal_locale_, other->legal_locale_);
+    std::swap(cache_expiration_, other->cache_expiration_);
+    std::swap(parental_control_info_, other->parental_control_info_);
+    std::swap(country_, other->country_);
+    std::swap(preferred_region_, other->preferred_region_);
+    std::swap(identity_check_status_, other->identity_check_status_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountBlob::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountBlob_descriptor_;
+  metadata.reflection = AccountBlob_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountBlobList::kBlobFieldNumber;
+#endif  // !_MSC_VER
+
+AccountBlobList::AccountBlobList()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountBlobList)
+}
+
+void AccountBlobList::InitAsDefaultInstance() {
+}
+
+AccountBlobList::AccountBlobList(const AccountBlobList& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountBlobList)
+}
+
+void AccountBlobList::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountBlobList::~AccountBlobList() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountBlobList)
+  SharedDtor();
+}
+
+void AccountBlobList::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void AccountBlobList::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountBlobList::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountBlobList_descriptor_;
+}
+
+const AccountBlobList& AccountBlobList::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+AccountBlobList* AccountBlobList::default_instance_ = NULL;
+
+AccountBlobList* AccountBlobList::New() const {
+  return new AccountBlobList;
+}
+
+void AccountBlobList::Clear() {
+  blob_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountBlobList::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountBlobList)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.account.v1.AccountBlob blob = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_blob:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_blob()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_blob;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountBlobList)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountBlobList)
+  return false;
+#undef DO_
+}
+
+void AccountBlobList::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountBlobList)
+  // repeated .bgs.protocol.account.v1.AccountBlob blob = 1;
+  for (int i = 0; i < this->blob_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->blob(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountBlobList)
+}
+
+::google::protobuf::uint8* AccountBlobList::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountBlobList)
+  // repeated .bgs.protocol.account.v1.AccountBlob blob = 1;
+  for (int i = 0; i < this->blob_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->blob(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountBlobList)
+  return target;
+}
+
+int AccountBlobList::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.account.v1.AccountBlob blob = 1;
+  total_size += 1 * this->blob_size();
+  for (int i = 0; i < this->blob_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->blob(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountBlobList::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountBlobList* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountBlobList*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountBlobList::MergeFrom(const AccountBlobList& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  blob_.MergeFrom(from.blob_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountBlobList::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountBlobList::CopyFrom(const AccountBlobList& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountBlobList::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->blob())) return false;
+  return true;
+}
+
+void AccountBlobList::Swap(AccountBlobList* other) {
+  if (other != this) {
+    blob_.Swap(&other->blob_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountBlobList::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountBlobList_descriptor_;
+  metadata.reflection = AccountBlobList_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameAccountHandle::kIdFieldNumber;
+const int GameAccountHandle::kProgramFieldNumber;
+const int GameAccountHandle::kRegionFieldNumber;
+#endif  // !_MSC_VER
+
+GameAccountHandle::GameAccountHandle()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountHandle)
+}
+
+void GameAccountHandle::InitAsDefaultInstance() {
+}
+
+GameAccountHandle::GameAccountHandle(const GameAccountHandle& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountHandle)
+}
+
+void GameAccountHandle::SharedCtor() {
+  _cached_size_ = 0;
+  id_ = 0u;
+  program_ = 0u;
+  region_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameAccountHandle::~GameAccountHandle() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountHandle)
+  SharedDtor();
+}
+
+void GameAccountHandle::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GameAccountHandle::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameAccountHandle::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameAccountHandle_descriptor_;
+}
+
+const GameAccountHandle& GameAccountHandle::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GameAccountHandle* GameAccountHandle::default_instance_ = NULL;
+
+GameAccountHandle* GameAccountHandle::New() const {
+  return new GameAccountHandle;
+}
+
+void GameAccountHandle::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GameAccountHandle*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(id_, region_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameAccountHandle::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountHandle)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required fixed32 id = 1;
+      case 1: {
+        if (tag == 13) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(21)) goto parse_program;
+        break;
+      }
+
+      // required fixed32 program = 2;
+      case 2: {
+        if (tag == 21) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_region;
+        break;
+      }
+
+      // required uint32 region = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_region:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &region_)));
+          set_has_region();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameAccountHandle)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountHandle)
+  return false;
+#undef DO_
+}
+
+void GameAccountHandle::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountHandle)
+  // required fixed32 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->id(), output);
+  }
+
+  // required fixed32 program = 2;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->program(), output);
+  }
+
+  // required uint32 region = 3;
+  if (has_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->region(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountHandle)
+}
+
+::google::protobuf::uint8* GameAccountHandle::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountHandle)
+  // required fixed32 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->id(), target);
+  }
+
+  // required fixed32 program = 2;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->program(), target);
+  }
+
+  // required uint32 region = 3;
+  if (has_region()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->region(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountHandle)
+  return target;
+}
+
+int GameAccountHandle::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required fixed32 id = 1;
+    if (has_id()) {
+      total_size += 1 + 4;
+    }
+
+    // required fixed32 program = 2;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+    // required uint32 region = 3;
+    if (has_region()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->region());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameAccountHandle::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameAccountHandle* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountHandle*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameAccountHandle::MergeFrom(const GameAccountHandle& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_region()) {
+      set_region(from.region());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameAccountHandle::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameAccountHandle::CopyFrom(const GameAccountHandle& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameAccountHandle::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
+
+  return true;
+}
+
+void GameAccountHandle::Swap(GameAccountHandle* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(program_, other->program_);
+    std::swap(region_, other->region_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameAccountHandle::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameAccountHandle_descriptor_;
+  metadata.reflection = GameAccountHandle_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameAccountLink::kGameAccountFieldNumber;
+const int GameAccountLink::kNameFieldNumber;
+#endif  // !_MSC_VER
+
+GameAccountLink::GameAccountLink()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountLink)
+}
+
+void GameAccountLink::InitAsDefaultInstance() {
+  game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance());
+}
+
+GameAccountLink::GameAccountLink(const GameAccountLink& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountLink)
+}
+
+void GameAccountLink::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  game_account_ = NULL;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameAccountLink::~GameAccountLink() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountLink)
+  SharedDtor();
+}
+
+void GameAccountLink::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (this != default_instance_) {
+    delete game_account_;
+  }
+}
+
+void GameAccountLink::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameAccountLink::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameAccountLink_descriptor_;
+}
+
+const GameAccountLink& GameAccountLink::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GameAccountLink* GameAccountLink::default_instance_ = NULL;
+
+GameAccountLink* GameAccountLink::New() const {
+  return new GameAccountLink;
+}
+
+void GameAccountLink::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_game_account()) {
+      if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
+    }
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameAccountLink::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountLink)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_name;
+        break;
+      }
+
+      // required string name = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameAccountLink)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountLink)
+  return false;
+#undef DO_
+}
+
+void GameAccountLink::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountLink)
+  // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+  if (has_game_account()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->game_account(), output);
+  }
+
+  // required string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->name(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountLink)
+}
+
+::google::protobuf::uint8* GameAccountLink::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountLink)
+  // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+  if (has_game_account()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->game_account(), target);
+  }
+
+  // required string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->name(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountLink)
+  return target;
+}
+
+int GameAccountLink::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+    if (has_game_account()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account());
+    }
+
+    // required string name = 2;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameAccountLink::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameAccountLink* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountLink*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameAccountLink::MergeFrom(const GameAccountLink& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_game_account()) {
+      mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account());
+    }
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameAccountLink::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameAccountLink::CopyFrom(const GameAccountLink& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameAccountLink::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  if (has_game_account()) {
+    if (!this->game_account().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GameAccountLink::Swap(GameAccountLink* other) {
+  if (other != this) {
+    std::swap(game_account_, other->game_account_);
+    std::swap(name_, other->name_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameAccountLink::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameAccountLink_descriptor_;
+  metadata.reflection = GameAccountLink_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameAccountBlob::kGameAccountFieldNumber;
+const int GameAccountBlob::kNameFieldNumber;
+const int GameAccountBlob::kRealmPermissionsFieldNumber;
+const int GameAccountBlob::kStatusFieldNumber;
+const int GameAccountBlob::kFlagsFieldNumber;
+const int GameAccountBlob::kBillingFlagsFieldNumber;
+const int GameAccountBlob::kCacheExpirationFieldNumber;
+const int GameAccountBlob::kSubscriptionExpirationFieldNumber;
+const int GameAccountBlob::kUnitsRemainingFieldNumber;
+const int GameAccountBlob::kStatusExpirationFieldNumber;
+const int GameAccountBlob::kBoxLevelFieldNumber;
+const int GameAccountBlob::kBoxLevelExpirationFieldNumber;
+const int GameAccountBlob::kLicensesFieldNumber;
+const int GameAccountBlob::kRafAccountFieldNumber;
+const int GameAccountBlob::kRafInfoFieldNumber;
+const int GameAccountBlob::kRafExpirationFieldNumber;
+#endif  // !_MSC_VER
+
+GameAccountBlob::GameAccountBlob()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountBlob)
+}
+
+void GameAccountBlob::InitAsDefaultInstance() {
+  game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance());
+}
+
+GameAccountBlob::GameAccountBlob(const GameAccountBlob& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountBlob)
+}
+
+void GameAccountBlob::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  game_account_ = NULL;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  realm_permissions_ = 0u;
+  status_ = 0u;
+  flags_ = GOOGLE_ULONGLONG(0);
+  billing_flags_ = 0u;
+  cache_expiration_ = GOOGLE_ULONGLONG(0);
+  subscription_expiration_ = GOOGLE_ULONGLONG(0);
+  units_remaining_ = 0u;
+  status_expiration_ = GOOGLE_ULONGLONG(0);
+  box_level_ = 0u;
+  box_level_expiration_ = GOOGLE_ULONGLONG(0);
+  raf_account_ = 0u;
+  raf_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  raf_expiration_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameAccountBlob::~GameAccountBlob() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountBlob)
+  SharedDtor();
+}
+
+void GameAccountBlob::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete raf_info_;
+  }
+  if (this != default_instance_) {
+    delete game_account_;
+  }
+}
+
+void GameAccountBlob::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameAccountBlob::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameAccountBlob_descriptor_;
+}
+
+const GameAccountBlob& GameAccountBlob::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GameAccountBlob* GameAccountBlob::default_instance_ = NULL;
+
+GameAccountBlob* GameAccountBlob::New() const {
+  return new GameAccountBlob;
+}
+
+void GameAccountBlob::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GameAccountBlob*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 255) {
+    ZR_(realm_permissions_, billing_flags_);
+    if (has_game_account()) {
+      if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
+    }
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    subscription_expiration_ = GOOGLE_ULONGLONG(0);
+  }
+  if (_has_bits_[8 / 32] & 61184) {
+    ZR_(status_expiration_, raf_account_);
+    units_remaining_ = 0u;
+    if (has_raf_info()) {
+      if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        raf_info_->clear();
+      }
+    }
+    raf_expiration_ = GOOGLE_ULONGLONG(0);
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  licenses_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameAccountBlob::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountBlob)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(16383);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_name;
+        break;
+      }
+
+      // optional string name = 2 [default = ""];
+      case 2: {
+        if (tag == 18) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_realm_permissions;
+        break;
+      }
+
+      // optional uint32 realm_permissions = 3 [default = 0];
+      case 3: {
+        if (tag == 24) {
+         parse_realm_permissions:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &realm_permissions_)));
+          set_has_realm_permissions();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_status;
+        break;
+      }
+
+      // required uint32 status = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_status:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &status_)));
+          set_has_status();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_flags;
+        break;
+      }
+
+      // optional uint64 flags = 5 [default = 0];
+      case 5: {
+        if (tag == 40) {
+         parse_flags:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &flags_)));
+          set_has_flags();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_billing_flags;
+        break;
+      }
+
+      // optional uint32 billing_flags = 6 [default = 0];
+      case 6: {
+        if (tag == 48) {
+         parse_billing_flags:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &billing_flags_)));
+          set_has_billing_flags();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_cache_expiration;
+        break;
+      }
+
+      // required uint64 cache_expiration = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_cache_expiration:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &cache_expiration_)));
+          set_has_cache_expiration();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(80)) goto parse_subscription_expiration;
+        break;
+      }
+
+      // optional uint64 subscription_expiration = 10;
+      case 10: {
+        if (tag == 80) {
+         parse_subscription_expiration:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &subscription_expiration_)));
+          set_has_subscription_expiration();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(88)) goto parse_units_remaining;
+        break;
+      }
+
+      // optional uint32 units_remaining = 11;
+      case 11: {
+        if (tag == 88) {
+         parse_units_remaining:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &units_remaining_)));
+          set_has_units_remaining();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(96)) goto parse_status_expiration;
+        break;
+      }
+
+      // optional uint64 status_expiration = 12;
+      case 12: {
+        if (tag == 96) {
+         parse_status_expiration:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &status_expiration_)));
+          set_has_status_expiration();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(104)) goto parse_box_level;
+        break;
+      }
+
+      // optional uint32 box_level = 13;
+      case 13: {
+        if (tag == 104) {
+         parse_box_level:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &box_level_)));
+          set_has_box_level();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(112)) goto parse_box_level_expiration;
+        break;
+      }
+
+      // optional uint64 box_level_expiration = 14;
+      case 14: {
+        if (tag == 112) {
+         parse_box_level_expiration:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &box_level_expiration_)));
+          set_has_box_level_expiration();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(162)) goto parse_licenses;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
+      case 20: {
+        if (tag == 162) {
+         parse_licenses:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_licenses()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(162)) goto parse_licenses;
+        if (input->ExpectTag(173)) goto parse_raf_account;
+        break;
+      }
+
+      // optional fixed32 raf_account = 21;
+      case 21: {
+        if (tag == 173) {
+         parse_raf_account:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &raf_account_)));
+          set_has_raf_account();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(178)) goto parse_raf_info;
+        break;
+      }
+
+      // optional bytes raf_info = 22;
+      case 22: {
+        if (tag == 178) {
+         parse_raf_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_raf_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(184)) goto parse_raf_expiration;
+        break;
+      }
+
+      // optional uint64 raf_expiration = 23;
+      case 23: {
+        if (tag == 184) {
+         parse_raf_expiration:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &raf_expiration_)));
+          set_has_raf_expiration();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameAccountBlob)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountBlob)
+  return false;
+#undef DO_
+}
+
+void GameAccountBlob::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountBlob)
+  // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+  if (has_game_account()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->game_account(), output);
+  }
+
+  // optional string name = 2 [default = ""];
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->name(), output);
+  }
+
+  // optional uint32 realm_permissions = 3 [default = 0];
+  if (has_realm_permissions()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->realm_permissions(), output);
+  }
+
+  // required uint32 status = 4;
+  if (has_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->status(), output);
+  }
+
+  // optional uint64 flags = 5 [default = 0];
+  if (has_flags()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->flags(), output);
+  }
+
+  // optional uint32 billing_flags = 6 [default = 0];
+  if (has_billing_flags()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->billing_flags(), output);
+  }
+
+  // required uint64 cache_expiration = 7;
+  if (has_cache_expiration()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(7, this->cache_expiration(), output);
+  }
+
+  // optional uint64 subscription_expiration = 10;
+  if (has_subscription_expiration()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(10, this->subscription_expiration(), output);
+  }
+
+  // optional uint32 units_remaining = 11;
+  if (has_units_remaining()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(11, this->units_remaining(), output);
+  }
+
+  // optional uint64 status_expiration = 12;
+  if (has_status_expiration()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(12, this->status_expiration(), output);
+  }
+
+  // optional uint32 box_level = 13;
+  if (has_box_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(13, this->box_level(), output);
+  }
+
+  // optional uint64 box_level_expiration = 14;
+  if (has_box_level_expiration()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(14, this->box_level_expiration(), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
+  for (int i = 0; i < this->licenses_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      20, this->licenses(i), output);
+  }
+
+  // optional fixed32 raf_account = 21;
+  if (has_raf_account()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(21, this->raf_account(), output);
+  }
+
+  // optional bytes raf_info = 22;
+  if (has_raf_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      22, this->raf_info(), output);
+  }
+
+  // optional uint64 raf_expiration = 23;
+  if (has_raf_expiration()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(23, this->raf_expiration(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountBlob)
+}
+
+::google::protobuf::uint8* GameAccountBlob::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountBlob)
+  // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+  if (has_game_account()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->game_account(), target);
+  }
+
+  // optional string name = 2 [default = ""];
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->name(), target);
+  }
+
+  // optional uint32 realm_permissions = 3 [default = 0];
+  if (has_realm_permissions()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->realm_permissions(), target);
+  }
+
+  // required uint32 status = 4;
+  if (has_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->status(), target);
+  }
+
+  // optional uint64 flags = 5 [default = 0];
+  if (has_flags()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->flags(), target);
+  }
+
+  // optional uint32 billing_flags = 6 [default = 0];
+  if (has_billing_flags()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->billing_flags(), target);
+  }
+
+  // required uint64 cache_expiration = 7;
+  if (has_cache_expiration()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(7, this->cache_expiration(), target);
+  }
+
+  // optional uint64 subscription_expiration = 10;
+  if (has_subscription_expiration()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(10, this->subscription_expiration(), target);
+  }
+
+  // optional uint32 units_remaining = 11;
+  if (has_units_remaining()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(11, this->units_remaining(), target);
+  }
+
+  // optional uint64 status_expiration = 12;
+  if (has_status_expiration()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(12, this->status_expiration(), target);
+  }
+
+  // optional uint32 box_level = 13;
+  if (has_box_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(13, this->box_level(), target);
+  }
+
+  // optional uint64 box_level_expiration = 14;
+  if (has_box_level_expiration()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(14, this->box_level_expiration(), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
+  for (int i = 0; i < this->licenses_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        20, this->licenses(i), target);
+  }
+
+  // optional fixed32 raf_account = 21;
+  if (has_raf_account()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(21, this->raf_account(), target);
+  }
+
+  // optional bytes raf_info = 22;
+  if (has_raf_info()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        22, this->raf_info(), target);
+  }
+
+  // optional uint64 raf_expiration = 23;
+  if (has_raf_expiration()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(23, this->raf_expiration(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountBlob)
+  return target;
+}
+
+int GameAccountBlob::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+    if (has_game_account()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account());
+    }
+
+    // optional string name = 2 [default = ""];
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional uint32 realm_permissions = 3 [default = 0];
+    if (has_realm_permissions()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->realm_permissions());
+    }
+
+    // required uint32 status = 4;
+    if (has_status()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->status());
+    }
+
+    // optional uint64 flags = 5 [default = 0];
+    if (has_flags()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->flags());
+    }
+
+    // optional uint32 billing_flags = 6 [default = 0];
+    if (has_billing_flags()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->billing_flags());
+    }
+
+    // required uint64 cache_expiration = 7;
+    if (has_cache_expiration()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->cache_expiration());
+    }
+
+    // optional uint64 subscription_expiration = 10;
+    if (has_subscription_expiration()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->subscription_expiration());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional uint32 units_remaining = 11;
+    if (has_units_remaining()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->units_remaining());
+    }
+
+    // optional uint64 status_expiration = 12;
+    if (has_status_expiration()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->status_expiration());
+    }
+
+    // optional uint32 box_level = 13;
+    if (has_box_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->box_level());
+    }
+
+    // optional uint64 box_level_expiration = 14;
+    if (has_box_level_expiration()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->box_level_expiration());
+    }
+
+    // optional fixed32 raf_account = 21;
+    if (has_raf_account()) {
+      total_size += 2 + 4;
+    }
+
+    // optional bytes raf_info = 22;
+    if (has_raf_info()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->raf_info());
+    }
+
+    // optional uint64 raf_expiration = 23;
+    if (has_raf_expiration()) {
+      total_size += 2 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->raf_expiration());
+    }
+
+  }
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
+  total_size += 2 * this->licenses_size();
+  for (int i = 0; i < this->licenses_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->licenses(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameAccountBlob::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameAccountBlob* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountBlob*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameAccountBlob::MergeFrom(const GameAccountBlob& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  licenses_.MergeFrom(from.licenses_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_game_account()) {
+      mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account());
+    }
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_realm_permissions()) {
+      set_realm_permissions(from.realm_permissions());
+    }
+    if (from.has_status()) {
+      set_status(from.status());
+    }
+    if (from.has_flags()) {
+      set_flags(from.flags());
+    }
+    if (from.has_billing_flags()) {
+      set_billing_flags(from.billing_flags());
+    }
+    if (from.has_cache_expiration()) {
+      set_cache_expiration(from.cache_expiration());
+    }
+    if (from.has_subscription_expiration()) {
+      set_subscription_expiration(from.subscription_expiration());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_units_remaining()) {
+      set_units_remaining(from.units_remaining());
+    }
+    if (from.has_status_expiration()) {
+      set_status_expiration(from.status_expiration());
+    }
+    if (from.has_box_level()) {
+      set_box_level(from.box_level());
+    }
+    if (from.has_box_level_expiration()) {
+      set_box_level_expiration(from.box_level_expiration());
+    }
+    if (from.has_raf_account()) {
+      set_raf_account(from.raf_account());
+    }
+    if (from.has_raf_info()) {
+      set_raf_info(from.raf_info());
+    }
+    if (from.has_raf_expiration()) {
+      set_raf_expiration(from.raf_expiration());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameAccountBlob::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameAccountBlob::CopyFrom(const GameAccountBlob& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameAccountBlob::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000049) != 0x00000049) return false;
+
+  if (has_game_account()) {
+    if (!this->game_account().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->licenses())) return false;
+  return true;
+}
+
+void GameAccountBlob::Swap(GameAccountBlob* other) {
+  if (other != this) {
+    std::swap(game_account_, other->game_account_);
+    std::swap(name_, other->name_);
+    std::swap(realm_permissions_, other->realm_permissions_);
+    std::swap(status_, other->status_);
+    std::swap(flags_, other->flags_);
+    std::swap(billing_flags_, other->billing_flags_);
+    std::swap(cache_expiration_, other->cache_expiration_);
+    std::swap(subscription_expiration_, other->subscription_expiration_);
+    std::swap(units_remaining_, other->units_remaining_);
+    std::swap(status_expiration_, other->status_expiration_);
+    std::swap(box_level_, other->box_level_);
+    std::swap(box_level_expiration_, other->box_level_expiration_);
+    licenses_.Swap(&other->licenses_);
+    std::swap(raf_account_, other->raf_account_);
+    std::swap(raf_info_, other->raf_info_);
+    std::swap(raf_expiration_, other->raf_expiration_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameAccountBlob::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameAccountBlob_descriptor_;
+  metadata.reflection = GameAccountBlob_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameAccountBlobList::kBlobFieldNumber;
+#endif  // !_MSC_VER
+
+GameAccountBlobList::GameAccountBlobList()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountBlobList)
+}
+
+void GameAccountBlobList::InitAsDefaultInstance() {
+}
+
+GameAccountBlobList::GameAccountBlobList(const GameAccountBlobList& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountBlobList)
+}
+
+void GameAccountBlobList::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameAccountBlobList::~GameAccountBlobList() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountBlobList)
+  SharedDtor();
+}
+
+void GameAccountBlobList::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GameAccountBlobList::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameAccountBlobList::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameAccountBlobList_descriptor_;
+}
+
+const GameAccountBlobList& GameAccountBlobList::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GameAccountBlobList* GameAccountBlobList::default_instance_ = NULL;
+
+GameAccountBlobList* GameAccountBlobList::New() const {
+  return new GameAccountBlobList;
+}
+
+void GameAccountBlobList::Clear() {
+  blob_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameAccountBlobList::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountBlobList)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.account.v1.GameAccountBlob blob = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_blob:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_blob()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_blob;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameAccountBlobList)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountBlobList)
+  return false;
+#undef DO_
+}
+
+void GameAccountBlobList::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountBlobList)
+  // repeated .bgs.protocol.account.v1.GameAccountBlob blob = 1;
+  for (int i = 0; i < this->blob_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->blob(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountBlobList)
+}
+
+::google::protobuf::uint8* GameAccountBlobList::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountBlobList)
+  // repeated .bgs.protocol.account.v1.GameAccountBlob blob = 1;
+  for (int i = 0; i < this->blob_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->blob(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountBlobList)
+  return target;
+}
+
+int GameAccountBlobList::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.account.v1.GameAccountBlob blob = 1;
+  total_size += 1 * this->blob_size();
+  for (int i = 0; i < this->blob_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->blob(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameAccountBlobList::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameAccountBlobList* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountBlobList*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameAccountBlobList::MergeFrom(const GameAccountBlobList& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  blob_.MergeFrom(from.blob_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameAccountBlobList::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameAccountBlobList::CopyFrom(const GameAccountBlobList& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameAccountBlobList::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->blob())) return false;
+  return true;
+}
+
+void GameAccountBlobList::Swap(GameAccountBlobList* other) {
+  if (other != this) {
+    blob_.Swap(&other->blob_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameAccountBlobList::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameAccountBlobList_descriptor_;
+  metadata.reflection = GameAccountBlobList_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountReference::kIdFieldNumber;
+const int AccountReference::kEmailFieldNumber;
+const int AccountReference::kHandleFieldNumber;
+const int AccountReference::kBattleTagFieldNumber;
+const int AccountReference::kRegionFieldNumber;
+#endif  // !_MSC_VER
+
+AccountReference::AccountReference()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountReference)
+}
+
+void AccountReference::InitAsDefaultInstance() {
+  handle_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance());
+}
+
+AccountReference::AccountReference(const AccountReference& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountReference)
+}
+
+void AccountReference::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = 0u;
+  email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  handle_ = NULL;
+  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  region_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountReference::~AccountReference() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountReference)
+  SharedDtor();
+}
+
+void AccountReference::SharedDtor() {
+  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete email_;
+  }
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete battle_tag_;
+  }
+  if (this != default_instance_) {
+    delete handle_;
+  }
+}
+
+void AccountReference::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountReference::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountReference_descriptor_;
+}
+
+const AccountReference& AccountReference::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+AccountReference* AccountReference::default_instance_ = NULL;
+
+AccountReference* AccountReference::New() const {
+  return new AccountReference;
+}
+
+void AccountReference::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<AccountReference*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 31) {
+    ZR_(id_, region_);
+    if (has_email()) {
+      if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        email_->clear();
+      }
+    }
+    if (has_handle()) {
+      if (handle_ != NULL) handle_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
+    }
+    if (has_battle_tag()) {
+      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        battle_tag_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountReference::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountReference)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional fixed32 id = 1;
+      case 1: {
+        if (tag == 13) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_email;
+        break;
+      }
+
+      // optional string email = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_email:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_email()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->email().data(), this->email().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "email");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_handle;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.GameAccountHandle handle = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_handle:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_handle()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_battle_tag;
+        break;
+      }
+
+      // optional string battle_tag = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_battle_tag:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_battle_tag()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->battle_tag().data(), this->battle_tag().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "battle_tag");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(80)) goto parse_region;
+        break;
+      }
+
+      // optional uint32 region = 10 [default = 0];
+      case 10: {
+        if (tag == 80) {
+         parse_region:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &region_)));
+          set_has_region();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountReference)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountReference)
+  return false;
+#undef DO_
+}
+
+void AccountReference::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountReference)
+  // optional fixed32 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->id(), output);
+  }
+
+  // optional string email = 2;
+  if (has_email()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->email().data(), this->email().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "email");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->email(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountHandle handle = 3;
+  if (has_handle()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->handle(), output);
+  }
+
+  // optional string battle_tag = 4;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->battle_tag(), output);
+  }
+
+  // optional uint32 region = 10 [default = 0];
+  if (has_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->region(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountReference)
+}
+
+::google::protobuf::uint8* AccountReference::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountReference)
+  // optional fixed32 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->id(), target);
+  }
+
+  // optional string email = 2;
+  if (has_email()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->email().data(), this->email().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "email");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->email(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountHandle handle = 3;
+  if (has_handle()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->handle(), target);
+  }
+
+  // optional string battle_tag = 4;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->battle_tag(), target);
+  }
+
+  // optional uint32 region = 10 [default = 0];
+  if (has_region()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->region(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountReference)
+  return target;
+}
+
+int AccountReference::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional fixed32 id = 1;
+    if (has_id()) {
+      total_size += 1 + 4;
+    }
+
+    // optional string email = 2;
+    if (has_email()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->email());
+    }
+
+    // optional .bgs.protocol.account.v1.GameAccountHandle handle = 3;
+    if (has_handle()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->handle());
+    }
+
+    // optional string battle_tag = 4;
+    if (has_battle_tag()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->battle_tag());
+    }
+
+    // optional uint32 region = 10 [default = 0];
+    if (has_region()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->region());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountReference::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountReference* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountReference*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountReference::MergeFrom(const AccountReference& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_email()) {
+      set_email(from.email());
+    }
+    if (from.has_handle()) {
+      mutable_handle()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.handle());
+    }
+    if (from.has_battle_tag()) {
+      set_battle_tag(from.battle_tag());
+    }
+    if (from.has_region()) {
+      set_region(from.region());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountReference::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountReference::CopyFrom(const AccountReference& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountReference::IsInitialized() const {
+
+  if (has_handle()) {
+    if (!this->handle().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AccountReference::Swap(AccountReference* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(email_, other->email_);
+    std::swap(handle_, other->handle_);
+    std::swap(battle_tag_, other->battle_tag_);
+    std::swap(region_, other->region_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountReference::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountReference_descriptor_;
+  metadata.reflection = AccountReference_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Identity::kAccountFieldNumber;
+const int Identity::kGameAccountFieldNumber;
+const int Identity::kProcessFieldNumber;
+#endif  // !_MSC_VER
+
+Identity::Identity()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.Identity)
+}
+
+void Identity::InitAsDefaultInstance() {
+  account_ = const_cast< ::bgs::protocol::account::v1::AccountId*>(&::bgs::protocol::account::v1::AccountId::default_instance());
+  game_account_ = const_cast< ::bgs::protocol::account::v1::GameAccountHandle*>(&::bgs::protocol::account::v1::GameAccountHandle::default_instance());
+  process_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+}
+
+Identity::Identity(const Identity& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.Identity)
+}
+
+void Identity::SharedCtor() {
+  _cached_size_ = 0;
+  account_ = NULL;
+  game_account_ = NULL;
+  process_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Identity::~Identity() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.Identity)
+  SharedDtor();
+}
+
+void Identity::SharedDtor() {
+  if (this != default_instance_) {
+    delete account_;
+    delete game_account_;
+    delete process_;
+  }
+}
+
+void Identity::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Identity::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Identity_descriptor_;
+}
+
+const Identity& Identity::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Identity* Identity::default_instance_ = NULL;
+
+Identity* Identity::New() const {
+  return new Identity;
+}
+
+void Identity::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_account()) {
+      if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
+    }
+    if (has_game_account()) {
+      if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
+    }
+    if (has_process()) {
+      if (process_ != NULL) process_->::bgs::protocol::ProcessId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Identity::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.Identity)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountId account = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_game_account;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_game_account:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_process;
+        break;
+      }
+
+      // optional .bgs.protocol.ProcessId process = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_process:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_process()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.Identity)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.Identity)
+  return false;
+#undef DO_
+}
+
+void Identity::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.Identity)
+  // optional .bgs.protocol.account.v1.AccountId account = 1;
+  if (has_account()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->account(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
+  if (has_game_account()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->game_account(), output);
+  }
+
+  // optional .bgs.protocol.ProcessId process = 3;
+  if (has_process()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->process(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.Identity)
+}
+
+::google::protobuf::uint8* Identity::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.Identity)
+  // optional .bgs.protocol.account.v1.AccountId account = 1;
+  if (has_account()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->account(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
+  if (has_game_account()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->game_account(), target);
+  }
+
+  // optional .bgs.protocol.ProcessId process = 3;
+  if (has_process()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->process(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.Identity)
+  return target;
+}
+
+int Identity::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountId account = 1;
+    if (has_account()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account());
+    }
+
+    // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
+    if (has_game_account()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account());
+    }
+
+    // optional .bgs.protocol.ProcessId process = 3;
+    if (has_process()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->process());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Identity::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Identity* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Identity*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Identity::MergeFrom(const Identity& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account()) {
+      mutable_account()->::bgs::protocol::account::v1::AccountId::MergeFrom(from.account());
+    }
+    if (from.has_game_account()) {
+      mutable_game_account()->::bgs::protocol::account::v1::GameAccountHandle::MergeFrom(from.game_account());
+    }
+    if (from.has_process()) {
+      mutable_process()->::bgs::protocol::ProcessId::MergeFrom(from.process());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Identity::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Identity::CopyFrom(const Identity& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Identity::IsInitialized() const {
+
+  if (has_account()) {
+    if (!this->account().IsInitialized()) return false;
+  }
+  if (has_game_account()) {
+    if (!this->game_account().IsInitialized()) return false;
+  }
+  if (has_process()) {
+    if (!this->process().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void Identity::Swap(Identity* other) {
+  if (other != this) {
+    std::swap(account_, other->account_);
+    std::swap(game_account_, other->game_account_);
+    std::swap(process_, other->process_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Identity::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Identity_descriptor_;
+  metadata.reflection = Identity_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ProgramTag::kProgramFieldNumber;
+const int ProgramTag::kTagFieldNumber;
+#endif  // !_MSC_VER
+
+ProgramTag::ProgramTag()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.ProgramTag)
+}
+
+void ProgramTag::InitAsDefaultInstance() {
+}
+
+ProgramTag::ProgramTag(const ProgramTag& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.ProgramTag)
+}
+
+void ProgramTag::SharedCtor() {
+  _cached_size_ = 0;
+  program_ = 0u;
+  tag_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ProgramTag::~ProgramTag() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.ProgramTag)
+  SharedDtor();
+}
+
+void ProgramTag::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ProgramTag::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ProgramTag::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ProgramTag_descriptor_;
+}
+
+const ProgramTag& ProgramTag::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ProgramTag* ProgramTag::default_instance_ = NULL;
+
+ProgramTag* ProgramTag::New() const {
+  return new ProgramTag;
+}
+
+void ProgramTag::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ProgramTag*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(program_, tag_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ProgramTag::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.ProgramTag)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional fixed32 program = 1;
+      case 1: {
+        if (tag == 13) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(21)) goto parse_tag;
+        break;
+      }
+
+      // optional fixed32 tag = 2;
+      case 2: {
+        if (tag == 21) {
+         parse_tag:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &tag_)));
+          set_has_tag();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.ProgramTag)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.ProgramTag)
+  return false;
+#undef DO_
+}
+
+void ProgramTag::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.ProgramTag)
+  // optional fixed32 program = 1;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->program(), output);
+  }
+
+  // optional fixed32 tag = 2;
+  if (has_tag()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->tag(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.ProgramTag)
+}
+
+::google::protobuf::uint8* ProgramTag::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.ProgramTag)
+  // optional fixed32 program = 1;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->program(), target);
+  }
+
+  // optional fixed32 tag = 2;
+  if (has_tag()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->tag(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.ProgramTag)
+  return target;
+}
+
+int ProgramTag::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional fixed32 program = 1;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+    // optional fixed32 tag = 2;
+    if (has_tag()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ProgramTag::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ProgramTag* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ProgramTag*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ProgramTag::MergeFrom(const ProgramTag& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_tag()) {
+      set_tag(from.tag());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ProgramTag::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ProgramTag::CopyFrom(const ProgramTag& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ProgramTag::IsInitialized() const {
+
+  return true;
+}
+
+void ProgramTag::Swap(ProgramTag* other) {
+  if (other != this) {
+    std::swap(program_, other->program_);
+    std::swap(tag_, other->tag_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ProgramTag::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ProgramTag_descriptor_;
+  metadata.reflection = ProgramTag_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RegionTag::kRegionFieldNumber;
+const int RegionTag::kTagFieldNumber;
+#endif  // !_MSC_VER
+
+RegionTag::RegionTag()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.RegionTag)
+}
+
+void RegionTag::InitAsDefaultInstance() {
+}
+
+RegionTag::RegionTag(const RegionTag& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.RegionTag)
+}
+
+void RegionTag::SharedCtor() {
+  _cached_size_ = 0;
+  region_ = 0u;
+  tag_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RegionTag::~RegionTag() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.RegionTag)
+  SharedDtor();
+}
+
+void RegionTag::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void RegionTag::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RegionTag::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RegionTag_descriptor_;
+}
+
+const RegionTag& RegionTag::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+RegionTag* RegionTag::default_instance_ = NULL;
+
+RegionTag* RegionTag::New() const {
+  return new RegionTag;
+}
+
+void RegionTag::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<RegionTag*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(region_, tag_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RegionTag::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.RegionTag)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional fixed32 region = 1;
+      case 1: {
+        if (tag == 13) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &region_)));
+          set_has_region();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(21)) goto parse_tag;
+        break;
+      }
+
+      // optional fixed32 tag = 2;
+      case 2: {
+        if (tag == 21) {
+         parse_tag:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &tag_)));
+          set_has_tag();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.RegionTag)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.RegionTag)
+  return false;
+#undef DO_
+}
+
+void RegionTag::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.RegionTag)
+  // optional fixed32 region = 1;
+  if (has_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->region(), output);
+  }
+
+  // optional fixed32 tag = 2;
+  if (has_tag()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->tag(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.RegionTag)
+}
+
+::google::protobuf::uint8* RegionTag::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.RegionTag)
+  // optional fixed32 region = 1;
+  if (has_region()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->region(), target);
+  }
+
+  // optional fixed32 tag = 2;
+  if (has_tag()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->tag(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.RegionTag)
+  return target;
+}
+
+int RegionTag::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional fixed32 region = 1;
+    if (has_region()) {
+      total_size += 1 + 4;
+    }
+
+    // optional fixed32 tag = 2;
+    if (has_tag()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RegionTag::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RegionTag* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RegionTag*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RegionTag::MergeFrom(const RegionTag& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_region()) {
+      set_region(from.region());
+    }
+    if (from.has_tag()) {
+      set_tag(from.tag());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RegionTag::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RegionTag::CopyFrom(const RegionTag& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RegionTag::IsInitialized() const {
+
+  return true;
+}
+
+void RegionTag::Swap(RegionTag* other) {
+  if (other != this) {
+    std::swap(region_, other->region_);
+    std::swap(tag_, other->tag_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RegionTag::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RegionTag_descriptor_;
+  metadata.reflection = RegionTag_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountFieldTags::kAccountLevelInfoTagFieldNumber;
+const int AccountFieldTags::kPrivacyInfoTagFieldNumber;
+const int AccountFieldTags::kParentalControlInfoTagFieldNumber;
+const int AccountFieldTags::kGameLevelInfoTagsFieldNumber;
+const int AccountFieldTags::kGameStatusTagsFieldNumber;
+const int AccountFieldTags::kGameAccountTagsFieldNumber;
+#endif  // !_MSC_VER
+
+AccountFieldTags::AccountFieldTags()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountFieldTags)
+}
+
+void AccountFieldTags::InitAsDefaultInstance() {
+}
+
+AccountFieldTags::AccountFieldTags(const AccountFieldTags& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountFieldTags)
+}
+
+void AccountFieldTags::SharedCtor() {
+  _cached_size_ = 0;
+  account_level_info_tag_ = 0u;
+  privacy_info_tag_ = 0u;
+  parental_control_info_tag_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountFieldTags::~AccountFieldTags() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountFieldTags)
+  SharedDtor();
+}
+
+void AccountFieldTags::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void AccountFieldTags::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountFieldTags::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountFieldTags_descriptor_;
+}
+
+const AccountFieldTags& AccountFieldTags::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+AccountFieldTags* AccountFieldTags::default_instance_ = NULL;
+
+AccountFieldTags* AccountFieldTags::New() const {
+  return new AccountFieldTags;
+}
+
+void AccountFieldTags::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<AccountFieldTags*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(account_level_info_tag_, privacy_info_tag_);
+    parental_control_info_tag_ = 0u;
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  game_level_info_tags_.Clear();
+  game_status_tags_.Clear();
+  game_account_tags_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountFieldTags::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountFieldTags)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional fixed32 account_level_info_tag = 2;
+      case 2: {
+        if (tag == 21) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &account_level_info_tag_)));
+          set_has_account_level_info_tag();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(29)) goto parse_privacy_info_tag;
+        break;
+      }
+
+      // optional fixed32 privacy_info_tag = 3;
+      case 3: {
+        if (tag == 29) {
+         parse_privacy_info_tag:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &privacy_info_tag_)));
+          set_has_privacy_info_tag();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(37)) goto parse_parental_control_info_tag;
+        break;
+      }
+
+      // optional fixed32 parental_control_info_tag = 4;
+      case 4: {
+        if (tag == 37) {
+         parse_parental_control_info_tag:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &parental_control_info_tag_)));
+          set_has_parental_control_info_tag();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_game_level_info_tags;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.ProgramTag game_level_info_tags = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_game_level_info_tags:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_game_level_info_tags()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_game_level_info_tags;
+        if (input->ExpectTag(74)) goto parse_game_status_tags;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.ProgramTag game_status_tags = 9;
+      case 9: {
+        if (tag == 74) {
+         parse_game_status_tags:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_game_status_tags()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(74)) goto parse_game_status_tags;
+        if (input->ExpectTag(90)) goto parse_game_account_tags;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.RegionTag game_account_tags = 11;
+      case 11: {
+        if (tag == 90) {
+         parse_game_account_tags:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_game_account_tags()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(90)) goto parse_game_account_tags;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountFieldTags)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountFieldTags)
+  return false;
+#undef DO_
+}
+
+void AccountFieldTags::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountFieldTags)
+  // optional fixed32 account_level_info_tag = 2;
+  if (has_account_level_info_tag()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->account_level_info_tag(), output);
+  }
+
+  // optional fixed32 privacy_info_tag = 3;
+  if (has_privacy_info_tag()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->privacy_info_tag(), output);
+  }
+
+  // optional fixed32 parental_control_info_tag = 4;
+  if (has_parental_control_info_tag()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->parental_control_info_tag(), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.ProgramTag game_level_info_tags = 7;
+  for (int i = 0; i < this->game_level_info_tags_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      7, this->game_level_info_tags(i), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.ProgramTag game_status_tags = 9;
+  for (int i = 0; i < this->game_status_tags_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      9, this->game_status_tags(i), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.RegionTag game_account_tags = 11;
+  for (int i = 0; i < this->game_account_tags_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      11, this->game_account_tags(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountFieldTags)
+}
+
+::google::protobuf::uint8* AccountFieldTags::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountFieldTags)
+  // optional fixed32 account_level_info_tag = 2;
+  if (has_account_level_info_tag()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->account_level_info_tag(), target);
+  }
+
+  // optional fixed32 privacy_info_tag = 3;
+  if (has_privacy_info_tag()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->privacy_info_tag(), target);
+  }
+
+  // optional fixed32 parental_control_info_tag = 4;
+  if (has_parental_control_info_tag()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->parental_control_info_tag(), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.ProgramTag game_level_info_tags = 7;
+  for (int i = 0; i < this->game_level_info_tags_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        7, this->game_level_info_tags(i), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.ProgramTag game_status_tags = 9;
+  for (int i = 0; i < this->game_status_tags_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        9, this->game_status_tags(i), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.RegionTag game_account_tags = 11;
+  for (int i = 0; i < this->game_account_tags_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        11, this->game_account_tags(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountFieldTags)
+  return target;
+}
+
+int AccountFieldTags::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional fixed32 account_level_info_tag = 2;
+    if (has_account_level_info_tag()) {
+      total_size += 1 + 4;
+    }
+
+    // optional fixed32 privacy_info_tag = 3;
+    if (has_privacy_info_tag()) {
+      total_size += 1 + 4;
+    }
+
+    // optional fixed32 parental_control_info_tag = 4;
+    if (has_parental_control_info_tag()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  // repeated .bgs.protocol.account.v1.ProgramTag game_level_info_tags = 7;
+  total_size += 1 * this->game_level_info_tags_size();
+  for (int i = 0; i < this->game_level_info_tags_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->game_level_info_tags(i));
+  }
+
+  // repeated .bgs.protocol.account.v1.ProgramTag game_status_tags = 9;
+  total_size += 1 * this->game_status_tags_size();
+  for (int i = 0; i < this->game_status_tags_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->game_status_tags(i));
+  }
+
+  // repeated .bgs.protocol.account.v1.RegionTag game_account_tags = 11;
+  total_size += 1 * this->game_account_tags_size();
+  for (int i = 0; i < this->game_account_tags_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->game_account_tags(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountFieldTags::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountFieldTags* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountFieldTags*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountFieldTags::MergeFrom(const AccountFieldTags& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  game_level_info_tags_.MergeFrom(from.game_level_info_tags_);
+  game_status_tags_.MergeFrom(from.game_status_tags_);
+  game_account_tags_.MergeFrom(from.game_account_tags_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account_level_info_tag()) {
+      set_account_level_info_tag(from.account_level_info_tag());
+    }
+    if (from.has_privacy_info_tag()) {
+      set_privacy_info_tag(from.privacy_info_tag());
+    }
+    if (from.has_parental_control_info_tag()) {
+      set_parental_control_info_tag(from.parental_control_info_tag());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountFieldTags::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountFieldTags::CopyFrom(const AccountFieldTags& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountFieldTags::IsInitialized() const {
+
+  return true;
+}
+
+void AccountFieldTags::Swap(AccountFieldTags* other) {
+  if (other != this) {
+    std::swap(account_level_info_tag_, other->account_level_info_tag_);
+    std::swap(privacy_info_tag_, other->privacy_info_tag_);
+    std::swap(parental_control_info_tag_, other->parental_control_info_tag_);
+    game_level_info_tags_.Swap(&other->game_level_info_tags_);
+    game_status_tags_.Swap(&other->game_status_tags_);
+    game_account_tags_.Swap(&other->game_account_tags_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountFieldTags::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountFieldTags_descriptor_;
+  metadata.reflection = AccountFieldTags_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameAccountFieldTags::kGameLevelInfoTagFieldNumber;
+const int GameAccountFieldTags::kGameTimeInfoTagFieldNumber;
+const int GameAccountFieldTags::kGameStatusTagFieldNumber;
+const int GameAccountFieldTags::kRafInfoTagFieldNumber;
+#endif  // !_MSC_VER
+
+GameAccountFieldTags::GameAccountFieldTags()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountFieldTags)
+}
+
+void GameAccountFieldTags::InitAsDefaultInstance() {
+}
+
+GameAccountFieldTags::GameAccountFieldTags(const GameAccountFieldTags& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountFieldTags)
+}
+
+void GameAccountFieldTags::SharedCtor() {
+  _cached_size_ = 0;
+  game_level_info_tag_ = 0u;
+  game_time_info_tag_ = 0u;
+  game_status_tag_ = 0u;
+  raf_info_tag_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameAccountFieldTags::~GameAccountFieldTags() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountFieldTags)
+  SharedDtor();
+}
+
+void GameAccountFieldTags::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GameAccountFieldTags::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameAccountFieldTags::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameAccountFieldTags_descriptor_;
+}
+
+const GameAccountFieldTags& GameAccountFieldTags::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GameAccountFieldTags* GameAccountFieldTags::default_instance_ = NULL;
+
+GameAccountFieldTags* GameAccountFieldTags::New() const {
+  return new GameAccountFieldTags;
+}
+
+void GameAccountFieldTags::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GameAccountFieldTags*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(game_level_info_tag_, raf_info_tag_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameAccountFieldTags::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountFieldTags)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional fixed32 game_level_info_tag = 2;
+      case 2: {
+        if (tag == 21) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &game_level_info_tag_)));
+          set_has_game_level_info_tag();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(29)) goto parse_game_time_info_tag;
+        break;
+      }
+
+      // optional fixed32 game_time_info_tag = 3;
+      case 3: {
+        if (tag == 29) {
+         parse_game_time_info_tag:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &game_time_info_tag_)));
+          set_has_game_time_info_tag();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(37)) goto parse_game_status_tag;
+        break;
+      }
+
+      // optional fixed32 game_status_tag = 4;
+      case 4: {
+        if (tag == 37) {
+         parse_game_status_tag:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &game_status_tag_)));
+          set_has_game_status_tag();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(45)) goto parse_raf_info_tag;
+        break;
+      }
+
+      // optional fixed32 raf_info_tag = 5;
+      case 5: {
+        if (tag == 45) {
+         parse_raf_info_tag:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &raf_info_tag_)));
+          set_has_raf_info_tag();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameAccountFieldTags)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountFieldTags)
+  return false;
+#undef DO_
+}
+
+void GameAccountFieldTags::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountFieldTags)
+  // optional fixed32 game_level_info_tag = 2;
+  if (has_game_level_info_tag()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->game_level_info_tag(), output);
+  }
+
+  // optional fixed32 game_time_info_tag = 3;
+  if (has_game_time_info_tag()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->game_time_info_tag(), output);
+  }
+
+  // optional fixed32 game_status_tag = 4;
+  if (has_game_status_tag()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->game_status_tag(), output);
+  }
+
+  // optional fixed32 raf_info_tag = 5;
+  if (has_raf_info_tag()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->raf_info_tag(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountFieldTags)
+}
+
+::google::protobuf::uint8* GameAccountFieldTags::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountFieldTags)
+  // optional fixed32 game_level_info_tag = 2;
+  if (has_game_level_info_tag()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->game_level_info_tag(), target);
+  }
+
+  // optional fixed32 game_time_info_tag = 3;
+  if (has_game_time_info_tag()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->game_time_info_tag(), target);
+  }
+
+  // optional fixed32 game_status_tag = 4;
+  if (has_game_status_tag()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->game_status_tag(), target);
+  }
+
+  // optional fixed32 raf_info_tag = 5;
+  if (has_raf_info_tag()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->raf_info_tag(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountFieldTags)
+  return target;
+}
+
+int GameAccountFieldTags::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional fixed32 game_level_info_tag = 2;
+    if (has_game_level_info_tag()) {
+      total_size += 1 + 4;
+    }
+
+    // optional fixed32 game_time_info_tag = 3;
+    if (has_game_time_info_tag()) {
+      total_size += 1 + 4;
+    }
+
+    // optional fixed32 game_status_tag = 4;
+    if (has_game_status_tag()) {
+      total_size += 1 + 4;
+    }
+
+    // optional fixed32 raf_info_tag = 5;
+    if (has_raf_info_tag()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameAccountFieldTags::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameAccountFieldTags* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountFieldTags*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameAccountFieldTags::MergeFrom(const GameAccountFieldTags& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_game_level_info_tag()) {
+      set_game_level_info_tag(from.game_level_info_tag());
+    }
+    if (from.has_game_time_info_tag()) {
+      set_game_time_info_tag(from.game_time_info_tag());
+    }
+    if (from.has_game_status_tag()) {
+      set_game_status_tag(from.game_status_tag());
+    }
+    if (from.has_raf_info_tag()) {
+      set_raf_info_tag(from.raf_info_tag());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameAccountFieldTags::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameAccountFieldTags::CopyFrom(const GameAccountFieldTags& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameAccountFieldTags::IsInitialized() const {
+
+  return true;
+}
+
+void GameAccountFieldTags::Swap(GameAccountFieldTags* other) {
+  if (other != this) {
+    std::swap(game_level_info_tag_, other->game_level_info_tag_);
+    std::swap(game_time_info_tag_, other->game_time_info_tag_);
+    std::swap(game_status_tag_, other->game_status_tag_);
+    std::swap(raf_info_tag_, other->raf_info_tag_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameAccountFieldTags::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameAccountFieldTags_descriptor_;
+  metadata.reflection = GameAccountFieldTags_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountFieldOptions::kAllFieldsFieldNumber;
+const int AccountFieldOptions::kFieldAccountLevelInfoFieldNumber;
+const int AccountFieldOptions::kFieldPrivacyInfoFieldNumber;
+const int AccountFieldOptions::kFieldParentalControlInfoFieldNumber;
+const int AccountFieldOptions::kFieldGameLevelInfoFieldNumber;
+const int AccountFieldOptions::kFieldGameStatusFieldNumber;
+const int AccountFieldOptions::kFieldGameAccountsFieldNumber;
+#endif  // !_MSC_VER
+
+AccountFieldOptions::AccountFieldOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountFieldOptions)
+}
+
+void AccountFieldOptions::InitAsDefaultInstance() {
+}
+
+AccountFieldOptions::AccountFieldOptions(const AccountFieldOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountFieldOptions)
+}
+
+void AccountFieldOptions::SharedCtor() {
+  _cached_size_ = 0;
+  all_fields_ = false;
+  field_account_level_info_ = false;
+  field_privacy_info_ = false;
+  field_parental_control_info_ = false;
+  field_game_level_info_ = false;
+  field_game_status_ = false;
+  field_game_accounts_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountFieldOptions::~AccountFieldOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountFieldOptions)
+  SharedDtor();
+}
+
+void AccountFieldOptions::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void AccountFieldOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountFieldOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountFieldOptions_descriptor_;
+}
+
+const AccountFieldOptions& AccountFieldOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+AccountFieldOptions* AccountFieldOptions::default_instance_ = NULL;
+
+AccountFieldOptions* AccountFieldOptions::New() const {
+  return new AccountFieldOptions;
+}
+
+void AccountFieldOptions::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<AccountFieldOptions*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 127) {
+    ZR_(all_fields_, field_game_accounts_);
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountFieldOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountFieldOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bool all_fields = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &all_fields_)));
+          set_has_all_fields();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_field_account_level_info;
+        break;
+      }
+
+      // optional bool field_account_level_info = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_field_account_level_info:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &field_account_level_info_)));
+          set_has_field_account_level_info();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_field_privacy_info;
+        break;
+      }
+
+      // optional bool field_privacy_info = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_field_privacy_info:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &field_privacy_info_)));
+          set_has_field_privacy_info();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_field_parental_control_info;
+        break;
+      }
+
+      // optional bool field_parental_control_info = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_field_parental_control_info:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &field_parental_control_info_)));
+          set_has_field_parental_control_info();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_field_game_level_info;
+        break;
+      }
+
+      // optional bool field_game_level_info = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_field_game_level_info:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &field_game_level_info_)));
+          set_has_field_game_level_info();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_field_game_status;
+        break;
+      }
+
+      // optional bool field_game_status = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_field_game_status:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &field_game_status_)));
+          set_has_field_game_status();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_field_game_accounts;
+        break;
+      }
+
+      // optional bool field_game_accounts = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_field_game_accounts:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &field_game_accounts_)));
+          set_has_field_game_accounts();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountFieldOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountFieldOptions)
+  return false;
+#undef DO_
+}
+
+void AccountFieldOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountFieldOptions)
+  // optional bool all_fields = 1;
+  if (has_all_fields()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->all_fields(), output);
+  }
+
+  // optional bool field_account_level_info = 2;
+  if (has_field_account_level_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->field_account_level_info(), output);
+  }
+
+  // optional bool field_privacy_info = 3;
+  if (has_field_privacy_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->field_privacy_info(), output);
+  }
+
+  // optional bool field_parental_control_info = 4;
+  if (has_field_parental_control_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->field_parental_control_info(), output);
+  }
+
+  // optional bool field_game_level_info = 6;
+  if (has_field_game_level_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->field_game_level_info(), output);
+  }
+
+  // optional bool field_game_status = 7;
+  if (has_field_game_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->field_game_status(), output);
+  }
+
+  // optional bool field_game_accounts = 8;
+  if (has_field_game_accounts()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->field_game_accounts(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountFieldOptions)
+}
+
+::google::protobuf::uint8* AccountFieldOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountFieldOptions)
+  // optional bool all_fields = 1;
+  if (has_all_fields()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->all_fields(), target);
+  }
+
+  // optional bool field_account_level_info = 2;
+  if (has_field_account_level_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->field_account_level_info(), target);
+  }
+
+  // optional bool field_privacy_info = 3;
+  if (has_field_privacy_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->field_privacy_info(), target);
+  }
+
+  // optional bool field_parental_control_info = 4;
+  if (has_field_parental_control_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->field_parental_control_info(), target);
+  }
+
+  // optional bool field_game_level_info = 6;
+  if (has_field_game_level_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->field_game_level_info(), target);
+  }
+
+  // optional bool field_game_status = 7;
+  if (has_field_game_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->field_game_status(), target);
+  }
+
+  // optional bool field_game_accounts = 8;
+  if (has_field_game_accounts()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(8, this->field_game_accounts(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountFieldOptions)
+  return target;
+}
+
+int AccountFieldOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bool all_fields = 1;
+    if (has_all_fields()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool field_account_level_info = 2;
+    if (has_field_account_level_info()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool field_privacy_info = 3;
+    if (has_field_privacy_info()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool field_parental_control_info = 4;
+    if (has_field_parental_control_info()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool field_game_level_info = 6;
+    if (has_field_game_level_info()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool field_game_status = 7;
+    if (has_field_game_status()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool field_game_accounts = 8;
+    if (has_field_game_accounts()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountFieldOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountFieldOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountFieldOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountFieldOptions::MergeFrom(const AccountFieldOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_all_fields()) {
+      set_all_fields(from.all_fields());
+    }
+    if (from.has_field_account_level_info()) {
+      set_field_account_level_info(from.field_account_level_info());
+    }
+    if (from.has_field_privacy_info()) {
+      set_field_privacy_info(from.field_privacy_info());
+    }
+    if (from.has_field_parental_control_info()) {
+      set_field_parental_control_info(from.field_parental_control_info());
+    }
+    if (from.has_field_game_level_info()) {
+      set_field_game_level_info(from.field_game_level_info());
+    }
+    if (from.has_field_game_status()) {
+      set_field_game_status(from.field_game_status());
+    }
+    if (from.has_field_game_accounts()) {
+      set_field_game_accounts(from.field_game_accounts());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountFieldOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountFieldOptions::CopyFrom(const AccountFieldOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountFieldOptions::IsInitialized() const {
+
+  return true;
+}
+
+void AccountFieldOptions::Swap(AccountFieldOptions* other) {
+  if (other != this) {
+    std::swap(all_fields_, other->all_fields_);
+    std::swap(field_account_level_info_, other->field_account_level_info_);
+    std::swap(field_privacy_info_, other->field_privacy_info_);
+    std::swap(field_parental_control_info_, other->field_parental_control_info_);
+    std::swap(field_game_level_info_, other->field_game_level_info_);
+    std::swap(field_game_status_, other->field_game_status_);
+    std::swap(field_game_accounts_, other->field_game_accounts_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountFieldOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountFieldOptions_descriptor_;
+  metadata.reflection = AccountFieldOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameAccountFieldOptions::kAllFieldsFieldNumber;
+const int GameAccountFieldOptions::kFieldGameLevelInfoFieldNumber;
+const int GameAccountFieldOptions::kFieldGameTimeInfoFieldNumber;
+const int GameAccountFieldOptions::kFieldGameStatusFieldNumber;
+const int GameAccountFieldOptions::kFieldRafInfoFieldNumber;
+#endif  // !_MSC_VER
+
+GameAccountFieldOptions::GameAccountFieldOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountFieldOptions)
+}
+
+void GameAccountFieldOptions::InitAsDefaultInstance() {
+}
+
+GameAccountFieldOptions::GameAccountFieldOptions(const GameAccountFieldOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountFieldOptions)
+}
+
+void GameAccountFieldOptions::SharedCtor() {
+  _cached_size_ = 0;
+  all_fields_ = false;
+  field_game_level_info_ = false;
+  field_game_time_info_ = false;
+  field_game_status_ = false;
+  field_raf_info_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameAccountFieldOptions::~GameAccountFieldOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountFieldOptions)
+  SharedDtor();
+}
+
+void GameAccountFieldOptions::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GameAccountFieldOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameAccountFieldOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameAccountFieldOptions_descriptor_;
+}
+
+const GameAccountFieldOptions& GameAccountFieldOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GameAccountFieldOptions* GameAccountFieldOptions::default_instance_ = NULL;
+
+GameAccountFieldOptions* GameAccountFieldOptions::New() const {
+  return new GameAccountFieldOptions;
+}
+
+void GameAccountFieldOptions::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GameAccountFieldOptions*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 31) {
+    ZR_(all_fields_, field_raf_info_);
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameAccountFieldOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountFieldOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bool all_fields = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &all_fields_)));
+          set_has_all_fields();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_field_game_level_info;
+        break;
+      }
+
+      // optional bool field_game_level_info = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_field_game_level_info:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &field_game_level_info_)));
+          set_has_field_game_level_info();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_field_game_time_info;
+        break;
+      }
+
+      // optional bool field_game_time_info = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_field_game_time_info:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &field_game_time_info_)));
+          set_has_field_game_time_info();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_field_game_status;
+        break;
+      }
+
+      // optional bool field_game_status = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_field_game_status:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &field_game_status_)));
+          set_has_field_game_status();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_field_raf_info;
+        break;
+      }
+
+      // optional bool field_raf_info = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_field_raf_info:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &field_raf_info_)));
+          set_has_field_raf_info();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameAccountFieldOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountFieldOptions)
+  return false;
+#undef DO_
+}
+
+void GameAccountFieldOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountFieldOptions)
+  // optional bool all_fields = 1;
+  if (has_all_fields()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->all_fields(), output);
+  }
+
+  // optional bool field_game_level_info = 2;
+  if (has_field_game_level_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->field_game_level_info(), output);
+  }
+
+  // optional bool field_game_time_info = 3;
+  if (has_field_game_time_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->field_game_time_info(), output);
+  }
+
+  // optional bool field_game_status = 4;
+  if (has_field_game_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->field_game_status(), output);
+  }
+
+  // optional bool field_raf_info = 5;
+  if (has_field_raf_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->field_raf_info(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountFieldOptions)
+}
+
+::google::protobuf::uint8* GameAccountFieldOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountFieldOptions)
+  // optional bool all_fields = 1;
+  if (has_all_fields()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->all_fields(), target);
+  }
+
+  // optional bool field_game_level_info = 2;
+  if (has_field_game_level_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->field_game_level_info(), target);
+  }
+
+  // optional bool field_game_time_info = 3;
+  if (has_field_game_time_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->field_game_time_info(), target);
+  }
+
+  // optional bool field_game_status = 4;
+  if (has_field_game_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->field_game_status(), target);
+  }
+
+  // optional bool field_raf_info = 5;
+  if (has_field_raf_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->field_raf_info(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountFieldOptions)
+  return target;
+}
+
+int GameAccountFieldOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bool all_fields = 1;
+    if (has_all_fields()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool field_game_level_info = 2;
+    if (has_field_game_level_info()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool field_game_time_info = 3;
+    if (has_field_game_time_info()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool field_game_status = 4;
+    if (has_field_game_status()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool field_raf_info = 5;
+    if (has_field_raf_info()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameAccountFieldOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameAccountFieldOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountFieldOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameAccountFieldOptions::MergeFrom(const GameAccountFieldOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_all_fields()) {
+      set_all_fields(from.all_fields());
+    }
+    if (from.has_field_game_level_info()) {
+      set_field_game_level_info(from.field_game_level_info());
+    }
+    if (from.has_field_game_time_info()) {
+      set_field_game_time_info(from.field_game_time_info());
+    }
+    if (from.has_field_game_status()) {
+      set_field_game_status(from.field_game_status());
+    }
+    if (from.has_field_raf_info()) {
+      set_field_raf_info(from.field_raf_info());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameAccountFieldOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameAccountFieldOptions::CopyFrom(const GameAccountFieldOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameAccountFieldOptions::IsInitialized() const {
+
+  return true;
+}
+
+void GameAccountFieldOptions::Swap(GameAccountFieldOptions* other) {
+  if (other != this) {
+    std::swap(all_fields_, other->all_fields_);
+    std::swap(field_game_level_info_, other->field_game_level_info_);
+    std::swap(field_game_time_info_, other->field_game_time_info_);
+    std::swap(field_game_status_, other->field_game_status_);
+    std::swap(field_raf_info_, other->field_raf_info_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameAccountFieldOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameAccountFieldOptions_descriptor_;
+  metadata.reflection = GameAccountFieldOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscriberReference::kObjectIdFieldNumber;
+const int SubscriberReference::kEntityIdFieldNumber;
+const int SubscriberReference::kAccountOptionsFieldNumber;
+const int SubscriberReference::kAccountTagsFieldNumber;
+const int SubscriberReference::kGameAccountOptionsFieldNumber;
+const int SubscriberReference::kGameAccountTagsFieldNumber;
+const int SubscriberReference::kSubscriberIdFieldNumber;
+#endif  // !_MSC_VER
+
+SubscriberReference::SubscriberReference()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.SubscriberReference)
+}
+
+void SubscriberReference::InitAsDefaultInstance() {
+  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  account_options_ = const_cast< ::bgs::protocol::account::v1::AccountFieldOptions*>(&::bgs::protocol::account::v1::AccountFieldOptions::default_instance());
+  account_tags_ = const_cast< ::bgs::protocol::account::v1::AccountFieldTags*>(&::bgs::protocol::account::v1::AccountFieldTags::default_instance());
+  game_account_options_ = const_cast< ::bgs::protocol::account::v1::GameAccountFieldOptions*>(&::bgs::protocol::account::v1::GameAccountFieldOptions::default_instance());
+  game_account_tags_ = const_cast< ::bgs::protocol::account::v1::GameAccountFieldTags*>(&::bgs::protocol::account::v1::GameAccountFieldTags::default_instance());
+}
+
+SubscriberReference::SubscriberReference(const SubscriberReference& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.SubscriberReference)
+}
+
+void SubscriberReference::SharedCtor() {
+  _cached_size_ = 0;
+  object_id_ = GOOGLE_ULONGLONG(0);
+  entity_id_ = NULL;
+  account_options_ = NULL;
+  account_tags_ = NULL;
+  game_account_options_ = NULL;
+  game_account_tags_ = NULL;
+  subscriber_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscriberReference::~SubscriberReference() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.SubscriberReference)
+  SharedDtor();
+}
+
+void SubscriberReference::SharedDtor() {
+  if (this != default_instance_) {
+    delete entity_id_;
+    delete account_options_;
+    delete account_tags_;
+    delete game_account_options_;
+    delete game_account_tags_;
+  }
+}
+
+void SubscriberReference::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscriberReference::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscriberReference_descriptor_;
+}
+
+const SubscriberReference& SubscriberReference::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+SubscriberReference* SubscriberReference::default_instance_ = NULL;
+
+SubscriberReference* SubscriberReference::New() const {
+  return new SubscriberReference;
+}
+
+void SubscriberReference::Clear() {
+  if (_has_bits_[0 / 32] & 127) {
+    object_id_ = GOOGLE_ULONGLONG(0);
+    if (has_entity_id()) {
+      if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_account_options()) {
+      if (account_options_ != NULL) account_options_->::bgs::protocol::account::v1::AccountFieldOptions::Clear();
+    }
+    if (has_account_tags()) {
+      if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear();
+    }
+    if (has_game_account_options()) {
+      if (game_account_options_ != NULL) game_account_options_->::bgs::protocol::account::v1::GameAccountFieldOptions::Clear();
+    }
+    if (has_game_account_tags()) {
+      if (game_account_tags_ != NULL) game_account_tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear();
+    }
+    subscriber_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscriberReference::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.SubscriberReference)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 object_id = 1 [default = 0];
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &object_id_)));
+          set_has_object_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_entity_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId entity_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_entity_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_account_options;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountFieldOptions account_options = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_account_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_account_tags;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_account_tags:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_tags()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_game_account_options;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.GameAccountFieldOptions game_account_options = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_game_account_options:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_options()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_game_account_tags;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_game_account_tags:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_tags()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_subscriber_id;
+        break;
+      }
+
+      // optional uint64 subscriber_id = 7 [default = 0];
+      case 7: {
+        if (tag == 56) {
+         parse_subscriber_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &subscriber_id_)));
+          set_has_subscriber_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.SubscriberReference)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.SubscriberReference)
+  return false;
+#undef DO_
+}
+
+void SubscriberReference::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.SubscriberReference)
+  // optional uint64 object_id = 1 [default = 0];
+  if (has_object_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->object_id(), output);
+  }
+
+  // optional .bgs.protocol.EntityId entity_id = 2;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->entity_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountFieldOptions account_options = 3;
+  if (has_account_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->account_options(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 4;
+  if (has_account_tags()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->account_tags(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldOptions game_account_options = 5;
+  if (has_game_account_options()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->game_account_options(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 6;
+  if (has_game_account_tags()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->game_account_tags(), output);
+  }
+
+  // optional uint64 subscriber_id = 7 [default = 0];
+  if (has_subscriber_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(7, this->subscriber_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.SubscriberReference)
+}
+
+::google::protobuf::uint8* SubscriberReference::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.SubscriberReference)
+  // optional uint64 object_id = 1 [default = 0];
+  if (has_object_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->object_id(), target);
+  }
+
+  // optional .bgs.protocol.EntityId entity_id = 2;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->entity_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountFieldOptions account_options = 3;
+  if (has_account_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->account_options(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 4;
+  if (has_account_tags()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->account_tags(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldOptions game_account_options = 5;
+  if (has_game_account_options()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->game_account_options(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 6;
+  if (has_game_account_tags()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->game_account_tags(), target);
+  }
+
+  // optional uint64 subscriber_id = 7 [default = 0];
+  if (has_subscriber_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(7, this->subscriber_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.SubscriberReference)
+  return target;
+}
+
+int SubscriberReference::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 object_id = 1 [default = 0];
+    if (has_object_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->object_id());
+    }
+
+    // optional .bgs.protocol.EntityId entity_id = 2;
+    if (has_entity_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountFieldOptions account_options = 3;
+    if (has_account_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_options());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 4;
+    if (has_account_tags()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_tags());
+    }
+
+    // optional .bgs.protocol.account.v1.GameAccountFieldOptions game_account_options = 5;
+    if (has_game_account_options()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_options());
+    }
+
+    // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 6;
+    if (has_game_account_tags()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_tags());
+    }
+
+    // optional uint64 subscriber_id = 7 [default = 0];
+    if (has_subscriber_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->subscriber_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscriberReference::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscriberReference* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscriberReference*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscriberReference::MergeFrom(const SubscriberReference& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_object_id()) {
+      set_object_id(from.object_id());
+    }
+    if (from.has_entity_id()) {
+      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
+    }
+    if (from.has_account_options()) {
+      mutable_account_options()->::bgs::protocol::account::v1::AccountFieldOptions::MergeFrom(from.account_options());
+    }
+    if (from.has_account_tags()) {
+      mutable_account_tags()->::bgs::protocol::account::v1::AccountFieldTags::MergeFrom(from.account_tags());
+    }
+    if (from.has_game_account_options()) {
+      mutable_game_account_options()->::bgs::protocol::account::v1::GameAccountFieldOptions::MergeFrom(from.game_account_options());
+    }
+    if (from.has_game_account_tags()) {
+      mutable_game_account_tags()->::bgs::protocol::account::v1::GameAccountFieldTags::MergeFrom(from.game_account_tags());
+    }
+    if (from.has_subscriber_id()) {
+      set_subscriber_id(from.subscriber_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscriberReference::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscriberReference::CopyFrom(const SubscriberReference& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscriberReference::IsInitialized() const {
+
+  if (has_entity_id()) {
+    if (!this->entity_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SubscriberReference::Swap(SubscriberReference* other) {
+  if (other != this) {
+    std::swap(object_id_, other->object_id_);
+    std::swap(entity_id_, other->entity_id_);
+    std::swap(account_options_, other->account_options_);
+    std::swap(account_tags_, other->account_tags_);
+    std::swap(game_account_options_, other->game_account_options_);
+    std::swap(game_account_tags_, other->game_account_tags_);
+    std::swap(subscriber_id_, other->subscriber_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscriberReference::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscriberReference_descriptor_;
+  metadata.reflection = SubscriberReference_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountLevelInfo::kLicensesFieldNumber;
+const int AccountLevelInfo::kDefaultCurrencyFieldNumber;
+const int AccountLevelInfo::kCountryFieldNumber;
+const int AccountLevelInfo::kPreferredRegionFieldNumber;
+const int AccountLevelInfo::kFullNameFieldNumber;
+const int AccountLevelInfo::kBattleTagFieldNumber;
+const int AccountLevelInfo::kMutedFieldNumber;
+const int AccountLevelInfo::kManualReviewFieldNumber;
+const int AccountLevelInfo::kAccountPaidAnyFieldNumber;
+const int AccountLevelInfo::kIdentityCheckStatusFieldNumber;
+const int AccountLevelInfo::kEmailFieldNumber;
+#endif  // !_MSC_VER
+
+AccountLevelInfo::AccountLevelInfo()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountLevelInfo)
+}
+
+void AccountLevelInfo::InitAsDefaultInstance() {
+}
+
+AccountLevelInfo::AccountLevelInfo(const AccountLevelInfo& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountLevelInfo)
+}
+
+void AccountLevelInfo::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  default_currency_ = 0u;
+  country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  preferred_region_ = 0u;
+  full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  muted_ = false;
+  manual_review_ = false;
+  account_paid_any_ = false;
+  identity_check_status_ = 0;
+  email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountLevelInfo::~AccountLevelInfo() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountLevelInfo)
+  SharedDtor();
+}
+
+void AccountLevelInfo::SharedDtor() {
+  if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete country_;
+  }
+  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete full_name_;
+  }
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete battle_tag_;
+  }
+  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete email_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void AccountLevelInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountLevelInfo::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountLevelInfo_descriptor_;
+}
+
+const AccountLevelInfo& AccountLevelInfo::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+AccountLevelInfo* AccountLevelInfo::default_instance_ = NULL;
+
+AccountLevelInfo* AccountLevelInfo::New() const {
+  return new AccountLevelInfo;
+}
+
+void AccountLevelInfo::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<AccountLevelInfo*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 254) {
+    ZR_(default_currency_, preferred_region_);
+    ZR_(muted_, manual_review_);
+    if (has_country()) {
+      if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        country_->clear();
+      }
+    }
+    if (has_full_name()) {
+      if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        full_name_->clear();
+      }
+    }
+    if (has_battle_tag()) {
+      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        battle_tag_->clear();
+      }
+    }
+  }
+  if (_has_bits_[8 / 32] & 1792) {
+    ZR_(account_paid_any_, identity_check_status_);
+    if (has_email()) {
+      if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        email_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  licenses_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountLevelInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountLevelInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.account.v1.AccountLicense licenses = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_licenses:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_licenses()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_licenses;
+        if (input->ExpectTag(37)) goto parse_default_currency;
+        break;
+      }
+
+      // optional fixed32 default_currency = 4;
+      case 4: {
+        if (tag == 37) {
+         parse_default_currency:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &default_currency_)));
+          set_has_default_currency();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_country;
+        break;
+      }
+
+      // optional string country = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_country:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_country()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->country().data(), this->country().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "country");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_preferred_region;
+        break;
+      }
+
+      // optional uint32 preferred_region = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_preferred_region:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &preferred_region_)));
+          set_has_preferred_region();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_full_name;
+        break;
+      }
+
+      // optional string full_name = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_full_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_full_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->full_name().data(), this->full_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "full_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_battle_tag;
+        break;
+      }
+
+      // optional string battle_tag = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_battle_tag:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_battle_tag()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->battle_tag().data(), this->battle_tag().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "battle_tag");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(72)) goto parse_muted;
+        break;
+      }
+
+      // optional bool muted = 9;
+      case 9: {
+        if (tag == 72) {
+         parse_muted:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &muted_)));
+          set_has_muted();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(80)) goto parse_manual_review;
+        break;
+      }
+
+      // optional bool manual_review = 10;
+      case 10: {
+        if (tag == 80) {
+         parse_manual_review:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &manual_review_)));
+          set_has_manual_review();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(88)) goto parse_account_paid_any;
+        break;
+      }
+
+      // optional bool account_paid_any = 11;
+      case 11: {
+        if (tag == 88) {
+         parse_account_paid_any:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &account_paid_any_)));
+          set_has_account_paid_any();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(96)) goto parse_identity_check_status;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 12;
+      case 12: {
+        if (tag == 96) {
+         parse_identity_check_status:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::account::v1::IdentityVerificationStatus_IsValid(value)) {
+            set_identity_check_status(static_cast< ::bgs::protocol::account::v1::IdentityVerificationStatus >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(12, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(106)) goto parse_email;
+        break;
+      }
+
+      // optional string email = 13;
+      case 13: {
+        if (tag == 106) {
+         parse_email:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_email()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->email().data(), this->email().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "email");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountLevelInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountLevelInfo)
+  return false;
+#undef DO_
+}
+
+void AccountLevelInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountLevelInfo)
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 3;
+  for (int i = 0; i < this->licenses_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->licenses(i), output);
+  }
+
+  // optional fixed32 default_currency = 4;
+  if (has_default_currency()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->default_currency(), output);
+  }
+
+  // optional string country = 5;
+  if (has_country()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->country().data(), this->country().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "country");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      5, this->country(), output);
+  }
+
+  // optional uint32 preferred_region = 6;
+  if (has_preferred_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->preferred_region(), output);
+  }
+
+  // optional string full_name = 7;
+  if (has_full_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->full_name().data(), this->full_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "full_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      7, this->full_name(), output);
+  }
+
+  // optional string battle_tag = 8;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      8, this->battle_tag(), output);
+  }
+
+  // optional bool muted = 9;
+  if (has_muted()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->muted(), output);
+  }
+
+  // optional bool manual_review = 10;
+  if (has_manual_review()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->manual_review(), output);
+  }
+
+  // optional bool account_paid_any = 11;
+  if (has_account_paid_any()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(11, this->account_paid_any(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 12;
+  if (has_identity_check_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      12, this->identity_check_status(), output);
+  }
+
+  // optional string email = 13;
+  if (has_email()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->email().data(), this->email().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "email");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      13, this->email(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountLevelInfo)
+}
+
+::google::protobuf::uint8* AccountLevelInfo::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountLevelInfo)
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 3;
+  for (int i = 0; i < this->licenses_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->licenses(i), target);
+  }
+
+  // optional fixed32 default_currency = 4;
+  if (has_default_currency()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->default_currency(), target);
+  }
+
+  // optional string country = 5;
+  if (has_country()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->country().data(), this->country().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "country");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->country(), target);
+  }
+
+  // optional uint32 preferred_region = 6;
+  if (has_preferred_region()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->preferred_region(), target);
+  }
+
+  // optional string full_name = 7;
+  if (has_full_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->full_name().data(), this->full_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "full_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        7, this->full_name(), target);
+  }
+
+  // optional string battle_tag = 8;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        8, this->battle_tag(), target);
+  }
+
+  // optional bool muted = 9;
+  if (has_muted()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->muted(), target);
+  }
+
+  // optional bool manual_review = 10;
+  if (has_manual_review()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->manual_review(), target);
+  }
+
+  // optional bool account_paid_any = 11;
+  if (has_account_paid_any()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(11, this->account_paid_any(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 12;
+  if (has_identity_check_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      12, this->identity_check_status(), target);
+  }
+
+  // optional string email = 13;
+  if (has_email()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->email().data(), this->email().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "email");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        13, this->email(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountLevelInfo)
+  return target;
+}
+
+int AccountLevelInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional fixed32 default_currency = 4;
+    if (has_default_currency()) {
+      total_size += 1 + 4;
+    }
+
+    // optional string country = 5;
+    if (has_country()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->country());
+    }
+
+    // optional uint32 preferred_region = 6;
+    if (has_preferred_region()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->preferred_region());
+    }
+
+    // optional string full_name = 7;
+    if (has_full_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->full_name());
+    }
+
+    // optional string battle_tag = 8;
+    if (has_battle_tag()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->battle_tag());
+    }
+
+    // optional bool muted = 9;
+    if (has_muted()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool manual_review = 10;
+    if (has_manual_review()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional bool account_paid_any = 11;
+    if (has_account_paid_any()) {
+      total_size += 1 + 1;
+    }
+
+    // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 12;
+    if (has_identity_check_status()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->identity_check_status());
+    }
+
+    // optional string email = 13;
+    if (has_email()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->email());
+    }
+
+  }
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 3;
+  total_size += 1 * this->licenses_size();
+  for (int i = 0; i < this->licenses_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->licenses(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountLevelInfo::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountLevelInfo* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountLevelInfo*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountLevelInfo::MergeFrom(const AccountLevelInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  licenses_.MergeFrom(from.licenses_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_default_currency()) {
+      set_default_currency(from.default_currency());
+    }
+    if (from.has_country()) {
+      set_country(from.country());
+    }
+    if (from.has_preferred_region()) {
+      set_preferred_region(from.preferred_region());
+    }
+    if (from.has_full_name()) {
+      set_full_name(from.full_name());
+    }
+    if (from.has_battle_tag()) {
+      set_battle_tag(from.battle_tag());
+    }
+    if (from.has_muted()) {
+      set_muted(from.muted());
+    }
+    if (from.has_manual_review()) {
+      set_manual_review(from.manual_review());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_account_paid_any()) {
+      set_account_paid_any(from.account_paid_any());
+    }
+    if (from.has_identity_check_status()) {
+      set_identity_check_status(from.identity_check_status());
+    }
+    if (from.has_email()) {
+      set_email(from.email());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountLevelInfo::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountLevelInfo::CopyFrom(const AccountLevelInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountLevelInfo::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->licenses())) return false;
+  return true;
+}
+
+void AccountLevelInfo::Swap(AccountLevelInfo* other) {
+  if (other != this) {
+    licenses_.Swap(&other->licenses_);
+    std::swap(default_currency_, other->default_currency_);
+    std::swap(country_, other->country_);
+    std::swap(preferred_region_, other->preferred_region_);
+    std::swap(full_name_, other->full_name_);
+    std::swap(battle_tag_, other->battle_tag_);
+    std::swap(muted_, other->muted_);
+    std::swap(manual_review_, other->manual_review_);
+    std::swap(account_paid_any_, other->account_paid_any_);
+    std::swap(identity_check_status_, other->identity_check_status_);
+    std::swap(email_, other->email_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountLevelInfo::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountLevelInfo_descriptor_;
+  metadata.reflection = AccountLevelInfo_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+const ::google::protobuf::EnumDescriptor* PrivacyInfo_GameInfoPrivacy_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PrivacyInfo_GameInfoPrivacy_descriptor_;
+}
+bool PrivacyInfo_GameInfoPrivacy_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const PrivacyInfo_GameInfoPrivacy PrivacyInfo::PRIVACY_ME;
+const PrivacyInfo_GameInfoPrivacy PrivacyInfo::PRIVACY_FRIENDS;
+const PrivacyInfo_GameInfoPrivacy PrivacyInfo::PRIVACY_EVERYONE;
+const PrivacyInfo_GameInfoPrivacy PrivacyInfo::GameInfoPrivacy_MIN;
+const PrivacyInfo_GameInfoPrivacy PrivacyInfo::GameInfoPrivacy_MAX;
+const int PrivacyInfo::GameInfoPrivacy_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int PrivacyInfo::kIsUsingRidFieldNumber;
+const int PrivacyInfo::kIsRealIdVisibleForViewFriendsFieldNumber;
+const int PrivacyInfo::kIsHiddenFromFriendFinderFieldNumber;
+const int PrivacyInfo::kGameInfoPrivacyFieldNumber;
+#endif  // !_MSC_VER
+
+PrivacyInfo::PrivacyInfo()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.PrivacyInfo)
+}
+
+void PrivacyInfo::InitAsDefaultInstance() {
+}
+
+PrivacyInfo::PrivacyInfo(const PrivacyInfo& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.PrivacyInfo)
+}
+
+void PrivacyInfo::SharedCtor() {
+  _cached_size_ = 0;
+  is_using_rid_ = false;
+  is_real_id_visible_for_view_friends_ = false;
+  is_hidden_from_friend_finder_ = false;
+  game_info_privacy_ = 1;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+PrivacyInfo::~PrivacyInfo() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.PrivacyInfo)
+  SharedDtor();
+}
+
+void PrivacyInfo::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void PrivacyInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* PrivacyInfo::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PrivacyInfo_descriptor_;
+}
+
+const PrivacyInfo& PrivacyInfo::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+PrivacyInfo* PrivacyInfo::default_instance_ = NULL;
+
+PrivacyInfo* PrivacyInfo::New() const {
+  return new PrivacyInfo;
+}
+
+void PrivacyInfo::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<PrivacyInfo*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(is_using_rid_, is_hidden_from_friend_finder_);
+    game_info_privacy_ = 1;
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool PrivacyInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.PrivacyInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bool is_using_rid = 3;
+      case 3: {
+        if (tag == 24) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_using_rid_)));
+          set_has_is_using_rid();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_is_real_id_visible_for_view_friends;
+        break;
+      }
+
+      // optional bool is_real_id_visible_for_view_friends = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_is_real_id_visible_for_view_friends:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_real_id_visible_for_view_friends_)));
+          set_has_is_real_id_visible_for_view_friends();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_is_hidden_from_friend_finder;
+        break;
+      }
+
+      // optional bool is_hidden_from_friend_finder = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_is_hidden_from_friend_finder:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_hidden_from_friend_finder_)));
+          set_has_is_hidden_from_friend_finder();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_game_info_privacy;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.PrivacyInfo.GameInfoPrivacy game_info_privacy = 6 [default = PRIVACY_FRIENDS];
+      case 6: {
+        if (tag == 48) {
+         parse_game_info_privacy:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy_IsValid(value)) {
+            set_game_info_privacy(static_cast< ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(6, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.PrivacyInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.PrivacyInfo)
+  return false;
+#undef DO_
+}
+
+void PrivacyInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.PrivacyInfo)
+  // optional bool is_using_rid = 3;
+  if (has_is_using_rid()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->is_using_rid(), output);
+  }
+
+  // optional bool is_real_id_visible_for_view_friends = 4;
+  if (has_is_real_id_visible_for_view_friends()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_real_id_visible_for_view_friends(), output);
+  }
+
+  // optional bool is_hidden_from_friend_finder = 5;
+  if (has_is_hidden_from_friend_finder()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->is_hidden_from_friend_finder(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.PrivacyInfo.GameInfoPrivacy game_info_privacy = 6 [default = PRIVACY_FRIENDS];
+  if (has_game_info_privacy()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      6, this->game_info_privacy(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.PrivacyInfo)
+}
+
+::google::protobuf::uint8* PrivacyInfo::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.PrivacyInfo)
+  // optional bool is_using_rid = 3;
+  if (has_is_using_rid()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->is_using_rid(), target);
+  }
+
+  // optional bool is_real_id_visible_for_view_friends = 4;
+  if (has_is_real_id_visible_for_view_friends()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->is_real_id_visible_for_view_friends(), target);
+  }
+
+  // optional bool is_hidden_from_friend_finder = 5;
+  if (has_is_hidden_from_friend_finder()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->is_hidden_from_friend_finder(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.PrivacyInfo.GameInfoPrivacy game_info_privacy = 6 [default = PRIVACY_FRIENDS];
+  if (has_game_info_privacy()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      6, this->game_info_privacy(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.PrivacyInfo)
+  return target;
+}
+
+int PrivacyInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bool is_using_rid = 3;
+    if (has_is_using_rid()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool is_real_id_visible_for_view_friends = 4;
+    if (has_is_real_id_visible_for_view_friends()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool is_hidden_from_friend_finder = 5;
+    if (has_is_hidden_from_friend_finder()) {
+      total_size += 1 + 1;
+    }
+
+    // optional .bgs.protocol.account.v1.PrivacyInfo.GameInfoPrivacy game_info_privacy = 6 [default = PRIVACY_FRIENDS];
+    if (has_game_info_privacy()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->game_info_privacy());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void PrivacyInfo::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const PrivacyInfo* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const PrivacyInfo*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void PrivacyInfo::MergeFrom(const PrivacyInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_is_using_rid()) {
+      set_is_using_rid(from.is_using_rid());
+    }
+    if (from.has_is_real_id_visible_for_view_friends()) {
+      set_is_real_id_visible_for_view_friends(from.is_real_id_visible_for_view_friends());
+    }
+    if (from.has_is_hidden_from_friend_finder()) {
+      set_is_hidden_from_friend_finder(from.is_hidden_from_friend_finder());
+    }
+    if (from.has_game_info_privacy()) {
+      set_game_info_privacy(from.game_info_privacy());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PrivacyInfo::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void PrivacyInfo::CopyFrom(const PrivacyInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PrivacyInfo::IsInitialized() const {
+
+  return true;
+}
+
+void PrivacyInfo::Swap(PrivacyInfo* other) {
+  if (other != this) {
+    std::swap(is_using_rid_, other->is_using_rid_);
+    std::swap(is_real_id_visible_for_view_friends_, other->is_real_id_visible_for_view_friends_);
+    std::swap(is_hidden_from_friend_finder_, other->is_hidden_from_friend_finder_);
+    std::swap(game_info_privacy_, other->game_info_privacy_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata PrivacyInfo::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = PrivacyInfo_descriptor_;
+  metadata.reflection = PrivacyInfo_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ParentalControlInfo::kTimezoneFieldNumber;
+const int ParentalControlInfo::kMinutesPerDayFieldNumber;
+const int ParentalControlInfo::kMinutesPerWeekFieldNumber;
+const int ParentalControlInfo::kCanReceiveVoiceFieldNumber;
+const int ParentalControlInfo::kCanSendVoiceFieldNumber;
+const int ParentalControlInfo::kPlayScheduleFieldNumber;
+#endif  // !_MSC_VER
+
+ParentalControlInfo::ParentalControlInfo()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.ParentalControlInfo)
+}
+
+void ParentalControlInfo::InitAsDefaultInstance() {
+}
+
+ParentalControlInfo::ParentalControlInfo(const ParentalControlInfo& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.ParentalControlInfo)
+}
+
+void ParentalControlInfo::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  timezone_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  minutes_per_day_ = 0u;
+  minutes_per_week_ = 0u;
+  can_receive_voice_ = false;
+  can_send_voice_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ParentalControlInfo::~ParentalControlInfo() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.ParentalControlInfo)
+  SharedDtor();
+}
+
+void ParentalControlInfo::SharedDtor() {
+  if (timezone_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete timezone_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ParentalControlInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ParentalControlInfo::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ParentalControlInfo_descriptor_;
+}
+
+const ParentalControlInfo& ParentalControlInfo::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ParentalControlInfo* ParentalControlInfo::default_instance_ = NULL;
+
+ParentalControlInfo* ParentalControlInfo::New() const {
+  return new ParentalControlInfo;
+}
+
+void ParentalControlInfo::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ParentalControlInfo*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 31) {
+    ZR_(minutes_per_day_, minutes_per_week_);
+    ZR_(can_receive_voice_, can_send_voice_);
+    if (has_timezone()) {
+      if (timezone_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        timezone_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  play_schedule_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ParentalControlInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.ParentalControlInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string timezone = 3;
+      case 3: {
+        if (tag == 26) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_timezone()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->timezone().data(), this->timezone().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "timezone");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_minutes_per_day;
+        break;
+      }
+
+      // optional uint32 minutes_per_day = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_minutes_per_day:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &minutes_per_day_)));
+          set_has_minutes_per_day();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_minutes_per_week;
+        break;
+      }
+
+      // optional uint32 minutes_per_week = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_minutes_per_week:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &minutes_per_week_)));
+          set_has_minutes_per_week();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_can_receive_voice;
+        break;
+      }
+
+      // optional bool can_receive_voice = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_can_receive_voice:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_receive_voice_)));
+          set_has_can_receive_voice();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_can_send_voice;
+        break;
+      }
+
+      // optional bool can_send_voice = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_can_send_voice:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_send_voice_)));
+          set_has_can_send_voice();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_play_schedule;
+        break;
+      }
+
+      // repeated bool play_schedule = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_play_schedule:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 1, 64, input, this->mutable_play_schedule())));
+        } else if (tag == 66) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, this->mutable_play_schedule())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_play_schedule;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.ParentalControlInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.ParentalControlInfo)
+  return false;
+#undef DO_
+}
+
+void ParentalControlInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.ParentalControlInfo)
+  // optional string timezone = 3;
+  if (has_timezone()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->timezone().data(), this->timezone().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "timezone");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->timezone(), output);
+  }
+
+  // optional uint32 minutes_per_day = 4;
+  if (has_minutes_per_day()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->minutes_per_day(), output);
+  }
+
+  // optional uint32 minutes_per_week = 5;
+  if (has_minutes_per_week()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->minutes_per_week(), output);
+  }
+
+  // optional bool can_receive_voice = 6;
+  if (has_can_receive_voice()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->can_receive_voice(), output);
+  }
+
+  // optional bool can_send_voice = 7;
+  if (has_can_send_voice()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->can_send_voice(), output);
+  }
+
+  // repeated bool play_schedule = 8;
+  for (int i = 0; i < this->play_schedule_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(
+      8, this->play_schedule(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.ParentalControlInfo)
+}
+
+::google::protobuf::uint8* ParentalControlInfo::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.ParentalControlInfo)
+  // optional string timezone = 3;
+  if (has_timezone()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->timezone().data(), this->timezone().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "timezone");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->timezone(), target);
+  }
+
+  // optional uint32 minutes_per_day = 4;
+  if (has_minutes_per_day()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->minutes_per_day(), target);
+  }
+
+  // optional uint32 minutes_per_week = 5;
+  if (has_minutes_per_week()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->minutes_per_week(), target);
+  }
+
+  // optional bool can_receive_voice = 6;
+  if (has_can_receive_voice()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->can_receive_voice(), target);
+  }
+
+  // optional bool can_send_voice = 7;
+  if (has_can_send_voice()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->can_send_voice(), target);
+  }
+
+  // repeated bool play_schedule = 8;
+  for (int i = 0; i < this->play_schedule_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteBoolToArray(8, this->play_schedule(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.ParentalControlInfo)
+  return target;
+}
+
+int ParentalControlInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string timezone = 3;
+    if (has_timezone()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->timezone());
+    }
+
+    // optional uint32 minutes_per_day = 4;
+    if (has_minutes_per_day()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->minutes_per_day());
+    }
+
+    // optional uint32 minutes_per_week = 5;
+    if (has_minutes_per_week()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->minutes_per_week());
+    }
+
+    // optional bool can_receive_voice = 6;
+    if (has_can_receive_voice()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool can_send_voice = 7;
+    if (has_can_send_voice()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated bool play_schedule = 8;
+  {
+    int data_size = 0;
+    data_size = 1 * this->play_schedule_size();
+    total_size += 1 * this->play_schedule_size() + data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ParentalControlInfo::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ParentalControlInfo* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ParentalControlInfo*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ParentalControlInfo::MergeFrom(const ParentalControlInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  play_schedule_.MergeFrom(from.play_schedule_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_timezone()) {
+      set_timezone(from.timezone());
+    }
+    if (from.has_minutes_per_day()) {
+      set_minutes_per_day(from.minutes_per_day());
+    }
+    if (from.has_minutes_per_week()) {
+      set_minutes_per_week(from.minutes_per_week());
+    }
+    if (from.has_can_receive_voice()) {
+      set_can_receive_voice(from.can_receive_voice());
+    }
+    if (from.has_can_send_voice()) {
+      set_can_send_voice(from.can_send_voice());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ParentalControlInfo::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ParentalControlInfo::CopyFrom(const ParentalControlInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ParentalControlInfo::IsInitialized() const {
+
+  return true;
+}
+
+void ParentalControlInfo::Swap(ParentalControlInfo* other) {
+  if (other != this) {
+    std::swap(timezone_, other->timezone_);
+    std::swap(minutes_per_day_, other->minutes_per_day_);
+    std::swap(minutes_per_week_, other->minutes_per_week_);
+    std::swap(can_receive_voice_, other->can_receive_voice_);
+    std::swap(can_send_voice_, other->can_send_voice_);
+    play_schedule_.Swap(&other->play_schedule_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ParentalControlInfo::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ParentalControlInfo_descriptor_;
+  metadata.reflection = ParentalControlInfo_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameLevelInfo::kIsTrialFieldNumber;
+const int GameLevelInfo::kIsLifetimeFieldNumber;
+const int GameLevelInfo::kIsRestrictedFieldNumber;
+const int GameLevelInfo::kIsBetaFieldNumber;
+const int GameLevelInfo::kNameFieldNumber;
+const int GameLevelInfo::kProgramFieldNumber;
+const int GameLevelInfo::kLicensesFieldNumber;
+const int GameLevelInfo::kRealmPermissionsFieldNumber;
+#endif  // !_MSC_VER
+
+GameLevelInfo::GameLevelInfo()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameLevelInfo)
+}
+
+void GameLevelInfo::InitAsDefaultInstance() {
+}
+
+GameLevelInfo::GameLevelInfo(const GameLevelInfo& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameLevelInfo)
+}
+
+void GameLevelInfo::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  is_trial_ = false;
+  is_lifetime_ = false;
+  is_restricted_ = false;
+  is_beta_ = false;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  program_ = 0u;
+  realm_permissions_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameLevelInfo::~GameLevelInfo() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameLevelInfo)
+  SharedDtor();
+}
+
+void GameLevelInfo::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void GameLevelInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameLevelInfo::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameLevelInfo_descriptor_;
+}
+
+const GameLevelInfo& GameLevelInfo::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GameLevelInfo* GameLevelInfo::default_instance_ = NULL;
+
+GameLevelInfo* GameLevelInfo::New() const {
+  return new GameLevelInfo;
+}
+
+void GameLevelInfo::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GameLevelInfo*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 191) {
+    ZR_(is_trial_, program_);
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    realm_permissions_ = 0u;
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  licenses_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameLevelInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameLevelInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bool is_trial = 4;
+      case 4: {
+        if (tag == 32) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_trial_)));
+          set_has_is_trial();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_is_lifetime;
+        break;
+      }
+
+      // optional bool is_lifetime = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_is_lifetime:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_lifetime_)));
+          set_has_is_lifetime();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_is_restricted;
+        break;
+      }
+
+      // optional bool is_restricted = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_is_restricted:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_restricted_)));
+          set_has_is_restricted();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_is_beta;
+        break;
+      }
+
+      // optional bool is_beta = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_is_beta:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_beta_)));
+          set_has_is_beta();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_name;
+        break;
+      }
+
+      // optional string name = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(77)) goto parse_program;
+        break;
+      }
+
+      // optional fixed32 program = 9;
+      case 9: {
+        if (tag == 77) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_licenses;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.AccountLicense licenses = 10;
+      case 10: {
+        if (tag == 82) {
+         parse_licenses:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_licenses()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_licenses;
+        if (input->ExpectTag(88)) goto parse_realm_permissions;
+        break;
+      }
+
+      // optional uint32 realm_permissions = 11;
+      case 11: {
+        if (tag == 88) {
+         parse_realm_permissions:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &realm_permissions_)));
+          set_has_realm_permissions();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameLevelInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameLevelInfo)
+  return false;
+#undef DO_
+}
+
+void GameLevelInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameLevelInfo)
+  // optional bool is_trial = 4;
+  if (has_is_trial()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_trial(), output);
+  }
+
+  // optional bool is_lifetime = 5;
+  if (has_is_lifetime()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->is_lifetime(), output);
+  }
+
+  // optional bool is_restricted = 6;
+  if (has_is_restricted()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->is_restricted(), output);
+  }
+
+  // optional bool is_beta = 7;
+  if (has_is_beta()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->is_beta(), output);
+  }
+
+  // optional string name = 8;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      8, this->name(), output);
+  }
+
+  // optional fixed32 program = 9;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(9, this->program(), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 10;
+  for (int i = 0; i < this->licenses_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      10, this->licenses(i), output);
+  }
+
+  // optional uint32 realm_permissions = 11;
+  if (has_realm_permissions()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(11, this->realm_permissions(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameLevelInfo)
+}
+
+::google::protobuf::uint8* GameLevelInfo::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameLevelInfo)
+  // optional bool is_trial = 4;
+  if (has_is_trial()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->is_trial(), target);
+  }
+
+  // optional bool is_lifetime = 5;
+  if (has_is_lifetime()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->is_lifetime(), target);
+  }
+
+  // optional bool is_restricted = 6;
+  if (has_is_restricted()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->is_restricted(), target);
+  }
+
+  // optional bool is_beta = 7;
+  if (has_is_beta()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->is_beta(), target);
+  }
+
+  // optional string name = 8;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        8, this->name(), target);
+  }
+
+  // optional fixed32 program = 9;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(9, this->program(), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 10;
+  for (int i = 0; i < this->licenses_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        10, this->licenses(i), target);
+  }
+
+  // optional uint32 realm_permissions = 11;
+  if (has_realm_permissions()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(11, this->realm_permissions(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameLevelInfo)
+  return target;
+}
+
+int GameLevelInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bool is_trial = 4;
+    if (has_is_trial()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool is_lifetime = 5;
+    if (has_is_lifetime()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool is_restricted = 6;
+    if (has_is_restricted()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool is_beta = 7;
+    if (has_is_beta()) {
+      total_size += 1 + 1;
+    }
+
+    // optional string name = 8;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional fixed32 program = 9;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+    // optional uint32 realm_permissions = 11;
+    if (has_realm_permissions()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->realm_permissions());
+    }
+
+  }
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 10;
+  total_size += 1 * this->licenses_size();
+  for (int i = 0; i < this->licenses_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->licenses(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameLevelInfo::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameLevelInfo* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameLevelInfo*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameLevelInfo::MergeFrom(const GameLevelInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  licenses_.MergeFrom(from.licenses_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_is_trial()) {
+      set_is_trial(from.is_trial());
+    }
+    if (from.has_is_lifetime()) {
+      set_is_lifetime(from.is_lifetime());
+    }
+    if (from.has_is_restricted()) {
+      set_is_restricted(from.is_restricted());
+    }
+    if (from.has_is_beta()) {
+      set_is_beta(from.is_beta());
+    }
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_realm_permissions()) {
+      set_realm_permissions(from.realm_permissions());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameLevelInfo::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameLevelInfo::CopyFrom(const GameLevelInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameLevelInfo::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->licenses())) return false;
+  return true;
+}
+
+void GameLevelInfo::Swap(GameLevelInfo* other) {
+  if (other != this) {
+    std::swap(is_trial_, other->is_trial_);
+    std::swap(is_lifetime_, other->is_lifetime_);
+    std::swap(is_restricted_, other->is_restricted_);
+    std::swap(is_beta_, other->is_beta_);
+    std::swap(name_, other->name_);
+    std::swap(program_, other->program_);
+    licenses_.Swap(&other->licenses_);
+    std::swap(realm_permissions_, other->realm_permissions_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameLevelInfo::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameLevelInfo_descriptor_;
+  metadata.reflection = GameLevelInfo_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameTimeInfo::kIsUnlimitedPlayTimeFieldNumber;
+const int GameTimeInfo::kPlayTimeExpiresFieldNumber;
+const int GameTimeInfo::kIsSubscriptionFieldNumber;
+const int GameTimeInfo::kIsRecurringSubscriptionFieldNumber;
+#endif  // !_MSC_VER
+
+GameTimeInfo::GameTimeInfo()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameTimeInfo)
+}
+
+void GameTimeInfo::InitAsDefaultInstance() {
+}
+
+GameTimeInfo::GameTimeInfo(const GameTimeInfo& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameTimeInfo)
+}
+
+void GameTimeInfo::SharedCtor() {
+  _cached_size_ = 0;
+  is_unlimited_play_time_ = false;
+  play_time_expires_ = GOOGLE_ULONGLONG(0);
+  is_subscription_ = false;
+  is_recurring_subscription_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameTimeInfo::~GameTimeInfo() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameTimeInfo)
+  SharedDtor();
+}
+
+void GameTimeInfo::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GameTimeInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameTimeInfo::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameTimeInfo_descriptor_;
+}
+
+const GameTimeInfo& GameTimeInfo::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GameTimeInfo* GameTimeInfo::default_instance_ = NULL;
+
+GameTimeInfo* GameTimeInfo::New() const {
+  return new GameTimeInfo;
+}
+
+void GameTimeInfo::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GameTimeInfo*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(play_time_expires_, is_recurring_subscription_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameTimeInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameTimeInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bool is_unlimited_play_time = 3;
+      case 3: {
+        if (tag == 24) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_unlimited_play_time_)));
+          set_has_is_unlimited_play_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_play_time_expires;
+        break;
+      }
+
+      // optional uint64 play_time_expires = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_play_time_expires:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &play_time_expires_)));
+          set_has_play_time_expires();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_is_subscription;
+        break;
+      }
+
+      // optional bool is_subscription = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_is_subscription:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_subscription_)));
+          set_has_is_subscription();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_is_recurring_subscription;
+        break;
+      }
+
+      // optional bool is_recurring_subscription = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_is_recurring_subscription:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_recurring_subscription_)));
+          set_has_is_recurring_subscription();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameTimeInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameTimeInfo)
+  return false;
+#undef DO_
+}
+
+void GameTimeInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameTimeInfo)
+  // optional bool is_unlimited_play_time = 3;
+  if (has_is_unlimited_play_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->is_unlimited_play_time(), output);
+  }
+
+  // optional uint64 play_time_expires = 5;
+  if (has_play_time_expires()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->play_time_expires(), output);
+  }
+
+  // optional bool is_subscription = 6;
+  if (has_is_subscription()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->is_subscription(), output);
+  }
+
+  // optional bool is_recurring_subscription = 7;
+  if (has_is_recurring_subscription()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->is_recurring_subscription(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameTimeInfo)
+}
+
+::google::protobuf::uint8* GameTimeInfo::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameTimeInfo)
+  // optional bool is_unlimited_play_time = 3;
+  if (has_is_unlimited_play_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->is_unlimited_play_time(), target);
+  }
+
+  // optional uint64 play_time_expires = 5;
+  if (has_play_time_expires()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->play_time_expires(), target);
+  }
+
+  // optional bool is_subscription = 6;
+  if (has_is_subscription()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->is_subscription(), target);
+  }
+
+  // optional bool is_recurring_subscription = 7;
+  if (has_is_recurring_subscription()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->is_recurring_subscription(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameTimeInfo)
+  return target;
+}
+
+int GameTimeInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bool is_unlimited_play_time = 3;
+    if (has_is_unlimited_play_time()) {
+      total_size += 1 + 1;
+    }
+
+    // optional uint64 play_time_expires = 5;
+    if (has_play_time_expires()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->play_time_expires());
+    }
+
+    // optional bool is_subscription = 6;
+    if (has_is_subscription()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool is_recurring_subscription = 7;
+    if (has_is_recurring_subscription()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameTimeInfo::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameTimeInfo* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameTimeInfo*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameTimeInfo::MergeFrom(const GameTimeInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_is_unlimited_play_time()) {
+      set_is_unlimited_play_time(from.is_unlimited_play_time());
+    }
+    if (from.has_play_time_expires()) {
+      set_play_time_expires(from.play_time_expires());
+    }
+    if (from.has_is_subscription()) {
+      set_is_subscription(from.is_subscription());
+    }
+    if (from.has_is_recurring_subscription()) {
+      set_is_recurring_subscription(from.is_recurring_subscription());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameTimeInfo::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameTimeInfo::CopyFrom(const GameTimeInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameTimeInfo::IsInitialized() const {
+
+  return true;
+}
+
+void GameTimeInfo::Swap(GameTimeInfo* other) {
+  if (other != this) {
+    std::swap(is_unlimited_play_time_, other->is_unlimited_play_time_);
+    std::swap(play_time_expires_, other->play_time_expires_);
+    std::swap(is_subscription_, other->is_subscription_);
+    std::swap(is_recurring_subscription_, other->is_recurring_subscription_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameTimeInfo::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameTimeInfo_descriptor_;
+  metadata.reflection = GameTimeInfo_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameTimeRemainingInfo::kMinutesRemainingFieldNumber;
+const int GameTimeRemainingInfo::kParentalDailyMinutesRemainingFieldNumber;
+const int GameTimeRemainingInfo::kParentalWeeklyMinutesRemainingFieldNumber;
+const int GameTimeRemainingInfo::kSecondsRemainingUntilKickFieldNumber;
+#endif  // !_MSC_VER
+
+GameTimeRemainingInfo::GameTimeRemainingInfo()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameTimeRemainingInfo)
+}
+
+void GameTimeRemainingInfo::InitAsDefaultInstance() {
+}
+
+GameTimeRemainingInfo::GameTimeRemainingInfo(const GameTimeRemainingInfo& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameTimeRemainingInfo)
+}
+
+void GameTimeRemainingInfo::SharedCtor() {
+  _cached_size_ = 0;
+  minutes_remaining_ = 0u;
+  parental_daily_minutes_remaining_ = 0u;
+  parental_weekly_minutes_remaining_ = 0u;
+  seconds_remaining_until_kick_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameTimeRemainingInfo::~GameTimeRemainingInfo() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameTimeRemainingInfo)
+  SharedDtor();
+}
+
+void GameTimeRemainingInfo::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GameTimeRemainingInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameTimeRemainingInfo::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameTimeRemainingInfo_descriptor_;
+}
+
+const GameTimeRemainingInfo& GameTimeRemainingInfo::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GameTimeRemainingInfo* GameTimeRemainingInfo::default_instance_ = NULL;
+
+GameTimeRemainingInfo* GameTimeRemainingInfo::New() const {
+  return new GameTimeRemainingInfo;
+}
+
+void GameTimeRemainingInfo::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GameTimeRemainingInfo*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(minutes_remaining_, seconds_remaining_until_kick_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameTimeRemainingInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameTimeRemainingInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 minutes_remaining = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &minutes_remaining_)));
+          set_has_minutes_remaining();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_parental_daily_minutes_remaining;
+        break;
+      }
+
+      // optional uint32 parental_daily_minutes_remaining = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_parental_daily_minutes_remaining:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &parental_daily_minutes_remaining_)));
+          set_has_parental_daily_minutes_remaining();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_parental_weekly_minutes_remaining;
+        break;
+      }
+
+      // optional uint32 parental_weekly_minutes_remaining = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_parental_weekly_minutes_remaining:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &parental_weekly_minutes_remaining_)));
+          set_has_parental_weekly_minutes_remaining();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_seconds_remaining_until_kick;
+        break;
+      }
+
+      // optional uint32 seconds_remaining_until_kick = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_seconds_remaining_until_kick:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &seconds_remaining_until_kick_)));
+          set_has_seconds_remaining_until_kick();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameTimeRemainingInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameTimeRemainingInfo)
+  return false;
+#undef DO_
+}
+
+void GameTimeRemainingInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameTimeRemainingInfo)
+  // optional uint32 minutes_remaining = 1;
+  if (has_minutes_remaining()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->minutes_remaining(), output);
+  }
+
+  // optional uint32 parental_daily_minutes_remaining = 2;
+  if (has_parental_daily_minutes_remaining()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->parental_daily_minutes_remaining(), output);
+  }
+
+  // optional uint32 parental_weekly_minutes_remaining = 3;
+  if (has_parental_weekly_minutes_remaining()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->parental_weekly_minutes_remaining(), output);
+  }
+
+  // optional uint32 seconds_remaining_until_kick = 4;
+  if (has_seconds_remaining_until_kick()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->seconds_remaining_until_kick(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameTimeRemainingInfo)
+}
+
+::google::protobuf::uint8* GameTimeRemainingInfo::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameTimeRemainingInfo)
+  // optional uint32 minutes_remaining = 1;
+  if (has_minutes_remaining()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->minutes_remaining(), target);
+  }
+
+  // optional uint32 parental_daily_minutes_remaining = 2;
+  if (has_parental_daily_minutes_remaining()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->parental_daily_minutes_remaining(), target);
+  }
+
+  // optional uint32 parental_weekly_minutes_remaining = 3;
+  if (has_parental_weekly_minutes_remaining()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->parental_weekly_minutes_remaining(), target);
+  }
+
+  // optional uint32 seconds_remaining_until_kick = 4;
+  if (has_seconds_remaining_until_kick()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->seconds_remaining_until_kick(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameTimeRemainingInfo)
+  return target;
+}
+
+int GameTimeRemainingInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 minutes_remaining = 1;
+    if (has_minutes_remaining()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->minutes_remaining());
+    }
+
+    // optional uint32 parental_daily_minutes_remaining = 2;
+    if (has_parental_daily_minutes_remaining()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->parental_daily_minutes_remaining());
+    }
+
+    // optional uint32 parental_weekly_minutes_remaining = 3;
+    if (has_parental_weekly_minutes_remaining()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->parental_weekly_minutes_remaining());
+    }
+
+    // optional uint32 seconds_remaining_until_kick = 4;
+    if (has_seconds_remaining_until_kick()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->seconds_remaining_until_kick());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameTimeRemainingInfo::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameTimeRemainingInfo* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameTimeRemainingInfo*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameTimeRemainingInfo::MergeFrom(const GameTimeRemainingInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_minutes_remaining()) {
+      set_minutes_remaining(from.minutes_remaining());
+    }
+    if (from.has_parental_daily_minutes_remaining()) {
+      set_parental_daily_minutes_remaining(from.parental_daily_minutes_remaining());
+    }
+    if (from.has_parental_weekly_minutes_remaining()) {
+      set_parental_weekly_minutes_remaining(from.parental_weekly_minutes_remaining());
+    }
+    if (from.has_seconds_remaining_until_kick()) {
+      set_seconds_remaining_until_kick(from.seconds_remaining_until_kick());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameTimeRemainingInfo::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameTimeRemainingInfo::CopyFrom(const GameTimeRemainingInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameTimeRemainingInfo::IsInitialized() const {
+
+  return true;
+}
+
+void GameTimeRemainingInfo::Swap(GameTimeRemainingInfo* other) {
+  if (other != this) {
+    std::swap(minutes_remaining_, other->minutes_remaining_);
+    std::swap(parental_daily_minutes_remaining_, other->parental_daily_minutes_remaining_);
+    std::swap(parental_weekly_minutes_remaining_, other->parental_weekly_minutes_remaining_);
+    std::swap(seconds_remaining_until_kick_, other->seconds_remaining_until_kick_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameTimeRemainingInfo::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameTimeRemainingInfo_descriptor_;
+  metadata.reflection = GameTimeRemainingInfo_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameStatus::kIsSuspendedFieldNumber;
+const int GameStatus::kIsBannedFieldNumber;
+const int GameStatus::kSuspensionExpiresFieldNumber;
+const int GameStatus::kProgramFieldNumber;
+const int GameStatus::kIsLockedFieldNumber;
+const int GameStatus::kIsBamUnlockableFieldNumber;
+#endif  // !_MSC_VER
+
+GameStatus::GameStatus()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameStatus)
+}
+
+void GameStatus::InitAsDefaultInstance() {
+}
+
+GameStatus::GameStatus(const GameStatus& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameStatus)
+}
+
+void GameStatus::SharedCtor() {
+  _cached_size_ = 0;
+  is_suspended_ = false;
+  is_banned_ = false;
+  suspension_expires_ = GOOGLE_ULONGLONG(0);
+  program_ = 0u;
+  is_locked_ = false;
+  is_bam_unlockable_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameStatus::~GameStatus() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameStatus)
+  SharedDtor();
+}
+
+void GameStatus::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GameStatus::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameStatus::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameStatus_descriptor_;
+}
+
+const GameStatus& GameStatus::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GameStatus* GameStatus::default_instance_ = NULL;
+
+GameStatus* GameStatus::New() const {
+  return new GameStatus;
+}
+
+void GameStatus::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GameStatus*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 63) {
+    ZR_(suspension_expires_, program_);
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameStatus::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameStatus)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bool is_suspended = 4;
+      case 4: {
+        if (tag == 32) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_suspended_)));
+          set_has_is_suspended();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_is_banned;
+        break;
+      }
+
+      // optional bool is_banned = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_is_banned:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_banned_)));
+          set_has_is_banned();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_suspension_expires;
+        break;
+      }
+
+      // optional uint64 suspension_expires = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_suspension_expires:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &suspension_expires_)));
+          set_has_suspension_expires();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(61)) goto parse_program;
+        break;
+      }
+
+      // optional fixed32 program = 7;
+      case 7: {
+        if (tag == 61) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_is_locked;
+        break;
+      }
+
+      // optional bool is_locked = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_is_locked:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_locked_)));
+          set_has_is_locked();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(72)) goto parse_is_bam_unlockable;
+        break;
+      }
+
+      // optional bool is_bam_unlockable = 9;
+      case 9: {
+        if (tag == 72) {
+         parse_is_bam_unlockable:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_bam_unlockable_)));
+          set_has_is_bam_unlockable();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameStatus)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameStatus)
+  return false;
+#undef DO_
+}
+
+void GameStatus::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameStatus)
+  // optional bool is_suspended = 4;
+  if (has_is_suspended()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->is_suspended(), output);
+  }
+
+  // optional bool is_banned = 5;
+  if (has_is_banned()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->is_banned(), output);
+  }
+
+  // optional uint64 suspension_expires = 6;
+  if (has_suspension_expires()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(6, this->suspension_expires(), output);
+  }
+
+  // optional fixed32 program = 7;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(7, this->program(), output);
+  }
+
+  // optional bool is_locked = 8;
+  if (has_is_locked()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->is_locked(), output);
+  }
+
+  // optional bool is_bam_unlockable = 9;
+  if (has_is_bam_unlockable()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->is_bam_unlockable(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameStatus)
+}
+
+::google::protobuf::uint8* GameStatus::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameStatus)
+  // optional bool is_suspended = 4;
+  if (has_is_suspended()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->is_suspended(), target);
+  }
+
+  // optional bool is_banned = 5;
+  if (has_is_banned()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->is_banned(), target);
+  }
+
+  // optional uint64 suspension_expires = 6;
+  if (has_suspension_expires()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(6, this->suspension_expires(), target);
+  }
+
+  // optional fixed32 program = 7;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(7, this->program(), target);
+  }
+
+  // optional bool is_locked = 8;
+  if (has_is_locked()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(8, this->is_locked(), target);
+  }
+
+  // optional bool is_bam_unlockable = 9;
+  if (has_is_bam_unlockable()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->is_bam_unlockable(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameStatus)
+  return target;
+}
+
+int GameStatus::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bool is_suspended = 4;
+    if (has_is_suspended()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool is_banned = 5;
+    if (has_is_banned()) {
+      total_size += 1 + 1;
+    }
+
+    // optional uint64 suspension_expires = 6;
+    if (has_suspension_expires()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->suspension_expires());
+    }
+
+    // optional fixed32 program = 7;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+    // optional bool is_locked = 8;
+    if (has_is_locked()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool is_bam_unlockable = 9;
+    if (has_is_bam_unlockable()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameStatus::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameStatus* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameStatus*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameStatus::MergeFrom(const GameStatus& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_is_suspended()) {
+      set_is_suspended(from.is_suspended());
+    }
+    if (from.has_is_banned()) {
+      set_is_banned(from.is_banned());
+    }
+    if (from.has_suspension_expires()) {
+      set_suspension_expires(from.suspension_expires());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_is_locked()) {
+      set_is_locked(from.is_locked());
+    }
+    if (from.has_is_bam_unlockable()) {
+      set_is_bam_unlockable(from.is_bam_unlockable());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameStatus::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameStatus::CopyFrom(const GameStatus& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameStatus::IsInitialized() const {
+
+  return true;
+}
+
+void GameStatus::Swap(GameStatus* other) {
+  if (other != this) {
+    std::swap(is_suspended_, other->is_suspended_);
+    std::swap(is_banned_, other->is_banned_);
+    std::swap(suspension_expires_, other->suspension_expires_);
+    std::swap(program_, other->program_);
+    std::swap(is_locked_, other->is_locked_);
+    std::swap(is_bam_unlockable_, other->is_bam_unlockable_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameStatus::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameStatus_descriptor_;
+  metadata.reflection = GameStatus_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RAFInfo::kRafInfoFieldNumber;
+#endif  // !_MSC_VER
+
+RAFInfo::RAFInfo()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.RAFInfo)
+}
+
+void RAFInfo::InitAsDefaultInstance() {
+}
+
+RAFInfo::RAFInfo(const RAFInfo& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.RAFInfo)
+}
+
+void RAFInfo::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  raf_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RAFInfo::~RAFInfo() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.RAFInfo)
+  SharedDtor();
+}
+
+void RAFInfo::SharedDtor() {
+  if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete raf_info_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void RAFInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RAFInfo::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RAFInfo_descriptor_;
+}
+
+const RAFInfo& RAFInfo::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+RAFInfo* RAFInfo::default_instance_ = NULL;
+
+RAFInfo* RAFInfo::New() const {
+  return new RAFInfo;
+}
+
+void RAFInfo::Clear() {
+  if (has_raf_info()) {
+    if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      raf_info_->clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RAFInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.RAFInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes raf_info = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_raf_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.RAFInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.RAFInfo)
+  return false;
+#undef DO_
+}
+
+void RAFInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.RAFInfo)
+  // optional bytes raf_info = 1;
+  if (has_raf_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->raf_info(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.RAFInfo)
+}
+
+::google::protobuf::uint8* RAFInfo::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.RAFInfo)
+  // optional bytes raf_info = 1;
+  if (has_raf_info()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        1, this->raf_info(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.RAFInfo)
+  return target;
+}
+
+int RAFInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes raf_info = 1;
+    if (has_raf_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->raf_info());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RAFInfo::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RAFInfo* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RAFInfo*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RAFInfo::MergeFrom(const RAFInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_raf_info()) {
+      set_raf_info(from.raf_info());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RAFInfo::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RAFInfo::CopyFrom(const RAFInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RAFInfo::IsInitialized() const {
+
+  return true;
+}
+
+void RAFInfo::Swap(RAFInfo* other) {
+  if (other != this) {
+    std::swap(raf_info_, other->raf_info_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RAFInfo::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RAFInfo_descriptor_;
+  metadata.reflection = RAFInfo_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameSessionInfo::kStartTimeFieldNumber;
+const int GameSessionInfo::kLocationFieldNumber;
+const int GameSessionInfo::kHasBenefactorFieldNumber;
+const int GameSessionInfo::kIsUsingIgrFieldNumber;
+const int GameSessionInfo::kParentalControlsActiveFieldNumber;
+const int GameSessionInfo::kStartTimeSecFieldNumber;
+#endif  // !_MSC_VER
+
+GameSessionInfo::GameSessionInfo()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameSessionInfo)
+}
+
+void GameSessionInfo::InitAsDefaultInstance() {
+  location_ = const_cast< ::bgs::protocol::account::v1::GameSessionLocation*>(&::bgs::protocol::account::v1::GameSessionLocation::default_instance());
+}
+
+GameSessionInfo::GameSessionInfo(const GameSessionInfo& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameSessionInfo)
+}
+
+void GameSessionInfo::SharedCtor() {
+  _cached_size_ = 0;
+  start_time_ = 0u;
+  location_ = NULL;
+  has_benefactor_ = false;
+  is_using_igr_ = false;
+  parental_controls_active_ = false;
+  start_time_sec_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameSessionInfo::~GameSessionInfo() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameSessionInfo)
+  SharedDtor();
+}
+
+void GameSessionInfo::SharedDtor() {
+  if (this != default_instance_) {
+    delete location_;
+  }
+}
+
+void GameSessionInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameSessionInfo::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameSessionInfo_descriptor_;
+}
+
+const GameSessionInfo& GameSessionInfo::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GameSessionInfo* GameSessionInfo::default_instance_ = NULL;
+
+GameSessionInfo* GameSessionInfo::New() const {
+  return new GameSessionInfo;
+}
+
+void GameSessionInfo::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<GameSessionInfo*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 63) {
+    ZR_(start_time_, start_time_sec_);
+    if (has_location()) {
+      if (location_ != NULL) location_->::bgs::protocol::account::v1::GameSessionLocation::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameSessionInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameSessionInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 start_time = 3 [deprecated = true];
+      case 3: {
+        if (tag == 24) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &start_time_)));
+          set_has_start_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_location;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.GameSessionLocation location = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_location:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_location()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_has_benefactor;
+        break;
+      }
+
+      // optional bool has_benefactor = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_has_benefactor:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &has_benefactor_)));
+          set_has_has_benefactor();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_is_using_igr;
+        break;
+      }
+
+      // optional bool is_using_igr = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_is_using_igr:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_using_igr_)));
+          set_has_is_using_igr();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_parental_controls_active;
+        break;
+      }
+
+      // optional bool parental_controls_active = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_parental_controls_active:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &parental_controls_active_)));
+          set_has_parental_controls_active();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_start_time_sec;
+        break;
+      }
+
+      // optional uint64 start_time_sec = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_start_time_sec:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &start_time_sec_)));
+          set_has_start_time_sec();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameSessionInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameSessionInfo)
+  return false;
+#undef DO_
+}
+
+void GameSessionInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameSessionInfo)
+  // optional uint32 start_time = 3 [deprecated = true];
+  if (has_start_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->start_time(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.GameSessionLocation location = 4;
+  if (has_location()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->location(), output);
+  }
+
+  // optional bool has_benefactor = 5;
+  if (has_has_benefactor()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->has_benefactor(), output);
+  }
+
+  // optional bool is_using_igr = 6;
+  if (has_is_using_igr()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->is_using_igr(), output);
+  }
+
+  // optional bool parental_controls_active = 7;
+  if (has_parental_controls_active()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->parental_controls_active(), output);
+  }
+
+  // optional uint64 start_time_sec = 8;
+  if (has_start_time_sec()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->start_time_sec(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameSessionInfo)
+}
+
+::google::protobuf::uint8* GameSessionInfo::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameSessionInfo)
+  // optional uint32 start_time = 3 [deprecated = true];
+  if (has_start_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->start_time(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.GameSessionLocation location = 4;
+  if (has_location()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->location(), target);
+  }
+
+  // optional bool has_benefactor = 5;
+  if (has_has_benefactor()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->has_benefactor(), target);
+  }
+
+  // optional bool is_using_igr = 6;
+  if (has_is_using_igr()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->is_using_igr(), target);
+  }
+
+  // optional bool parental_controls_active = 7;
+  if (has_parental_controls_active()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->parental_controls_active(), target);
+  }
+
+  // optional uint64 start_time_sec = 8;
+  if (has_start_time_sec()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->start_time_sec(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameSessionInfo)
+  return target;
+}
+
+int GameSessionInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 start_time = 3 [deprecated = true];
+    if (has_start_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->start_time());
+    }
+
+    // optional .bgs.protocol.account.v1.GameSessionLocation location = 4;
+    if (has_location()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->location());
+    }
+
+    // optional bool has_benefactor = 5;
+    if (has_has_benefactor()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool is_using_igr = 6;
+    if (has_is_using_igr()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool parental_controls_active = 7;
+    if (has_parental_controls_active()) {
+      total_size += 1 + 1;
+    }
+
+    // optional uint64 start_time_sec = 8;
+    if (has_start_time_sec()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->start_time_sec());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameSessionInfo::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameSessionInfo* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameSessionInfo*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameSessionInfo::MergeFrom(const GameSessionInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_start_time()) {
+      set_start_time(from.start_time());
+    }
+    if (from.has_location()) {
+      mutable_location()->::bgs::protocol::account::v1::GameSessionLocation::MergeFrom(from.location());
+    }
+    if (from.has_has_benefactor()) {
+      set_has_benefactor(from.has_benefactor());
+    }
+    if (from.has_is_using_igr()) {
+      set_is_using_igr(from.is_using_igr());
+    }
+    if (from.has_parental_controls_active()) {
+      set_parental_controls_active(from.parental_controls_active());
+    }
+    if (from.has_start_time_sec()) {
+      set_start_time_sec(from.start_time_sec());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameSessionInfo::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameSessionInfo::CopyFrom(const GameSessionInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameSessionInfo::IsInitialized() const {
+
+  return true;
+}
+
+void GameSessionInfo::Swap(GameSessionInfo* other) {
+  if (other != this) {
+    std::swap(start_time_, other->start_time_);
+    std::swap(location_, other->location_);
+    std::swap(has_benefactor_, other->has_benefactor_);
+    std::swap(is_using_igr_, other->is_using_igr_);
+    std::swap(parental_controls_active_, other->parental_controls_active_);
+    std::swap(start_time_sec_, other->start_time_sec_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameSessionInfo::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameSessionInfo_descriptor_;
+  metadata.reflection = GameSessionInfo_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameSessionUpdateInfo::kCaisFieldNumber;
+#endif  // !_MSC_VER
+
+GameSessionUpdateInfo::GameSessionUpdateInfo()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameSessionUpdateInfo)
+}
+
+void GameSessionUpdateInfo::InitAsDefaultInstance() {
+  cais_ = const_cast< ::bgs::protocol::account::v1::CAIS*>(&::bgs::protocol::account::v1::CAIS::default_instance());
+}
+
+GameSessionUpdateInfo::GameSessionUpdateInfo(const GameSessionUpdateInfo& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameSessionUpdateInfo)
+}
+
+void GameSessionUpdateInfo::SharedCtor() {
+  _cached_size_ = 0;
+  cais_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameSessionUpdateInfo::~GameSessionUpdateInfo() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameSessionUpdateInfo)
+  SharedDtor();
+}
+
+void GameSessionUpdateInfo::SharedDtor() {
+  if (this != default_instance_) {
+    delete cais_;
+  }
+}
+
+void GameSessionUpdateInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameSessionUpdateInfo::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameSessionUpdateInfo_descriptor_;
+}
+
+const GameSessionUpdateInfo& GameSessionUpdateInfo::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GameSessionUpdateInfo* GameSessionUpdateInfo::default_instance_ = NULL;
+
+GameSessionUpdateInfo* GameSessionUpdateInfo::New() const {
+  return new GameSessionUpdateInfo;
+}
+
+void GameSessionUpdateInfo::Clear() {
+  if (has_cais()) {
+    if (cais_ != NULL) cais_->::bgs::protocol::account::v1::CAIS::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameSessionUpdateInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameSessionUpdateInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.CAIS cais = 8;
+      case 8: {
+        if (tag == 66) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_cais()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameSessionUpdateInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameSessionUpdateInfo)
+  return false;
+#undef DO_
+}
+
+void GameSessionUpdateInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameSessionUpdateInfo)
+  // optional .bgs.protocol.account.v1.CAIS cais = 8;
+  if (has_cais()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      8, this->cais(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameSessionUpdateInfo)
+}
+
+::google::protobuf::uint8* GameSessionUpdateInfo::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameSessionUpdateInfo)
+  // optional .bgs.protocol.account.v1.CAIS cais = 8;
+  if (has_cais()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        8, this->cais(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameSessionUpdateInfo)
+  return target;
+}
+
+int GameSessionUpdateInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.CAIS cais = 8;
+    if (has_cais()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->cais());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameSessionUpdateInfo::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameSessionUpdateInfo* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameSessionUpdateInfo*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameSessionUpdateInfo::MergeFrom(const GameSessionUpdateInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_cais()) {
+      mutable_cais()->::bgs::protocol::account::v1::CAIS::MergeFrom(from.cais());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameSessionUpdateInfo::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameSessionUpdateInfo::CopyFrom(const GameSessionUpdateInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameSessionUpdateInfo::IsInitialized() const {
+
+  return true;
+}
+
+void GameSessionUpdateInfo::Swap(GameSessionUpdateInfo* other) {
+  if (other != this) {
+    std::swap(cais_, other->cais_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameSessionUpdateInfo::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameSessionUpdateInfo_descriptor_;
+  metadata.reflection = GameSessionUpdateInfo_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameSessionLocation::kIpAddressFieldNumber;
+const int GameSessionLocation::kCountryFieldNumber;
+const int GameSessionLocation::kCityFieldNumber;
+#endif  // !_MSC_VER
+
+GameSessionLocation::GameSessionLocation()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameSessionLocation)
+}
+
+void GameSessionLocation::InitAsDefaultInstance() {
+}
+
+GameSessionLocation::GameSessionLocation(const GameSessionLocation& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameSessionLocation)
+}
+
+void GameSessionLocation::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  ip_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  country_ = 0u;
+  city_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameSessionLocation::~GameSessionLocation() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameSessionLocation)
+  SharedDtor();
+}
+
+void GameSessionLocation::SharedDtor() {
+  if (ip_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete ip_address_;
+  }
+  if (city_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete city_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void GameSessionLocation::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameSessionLocation::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameSessionLocation_descriptor_;
+}
+
+const GameSessionLocation& GameSessionLocation::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GameSessionLocation* GameSessionLocation::default_instance_ = NULL;
+
+GameSessionLocation* GameSessionLocation::New() const {
+  return new GameSessionLocation;
+}
+
+void GameSessionLocation::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_ip_address()) {
+      if (ip_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        ip_address_->clear();
+      }
+    }
+    country_ = 0u;
+    if (has_city()) {
+      if (city_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        city_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameSessionLocation::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameSessionLocation)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string ip_address = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_ip_address()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->ip_address().data(), this->ip_address().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "ip_address");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_country;
+        break;
+      }
+
+      // optional uint32 country = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_country:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &country_)));
+          set_has_country();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_city;
+        break;
+      }
+
+      // optional string city = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_city:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_city()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->city().data(), this->city().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "city");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameSessionLocation)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameSessionLocation)
+  return false;
+#undef DO_
+}
+
+void GameSessionLocation::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameSessionLocation)
+  // optional string ip_address = 1;
+  if (has_ip_address()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->ip_address().data(), this->ip_address().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "ip_address");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->ip_address(), output);
+  }
+
+  // optional uint32 country = 2;
+  if (has_country()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->country(), output);
+  }
+
+  // optional string city = 3;
+  if (has_city()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->city().data(), this->city().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "city");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->city(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameSessionLocation)
+}
+
+::google::protobuf::uint8* GameSessionLocation::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameSessionLocation)
+  // optional string ip_address = 1;
+  if (has_ip_address()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->ip_address().data(), this->ip_address().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "ip_address");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->ip_address(), target);
+  }
+
+  // optional uint32 country = 2;
+  if (has_country()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->country(), target);
+  }
+
+  // optional string city = 3;
+  if (has_city()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->city().data(), this->city().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "city");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->city(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameSessionLocation)
+  return target;
+}
+
+int GameSessionLocation::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string ip_address = 1;
+    if (has_ip_address()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->ip_address());
+    }
+
+    // optional uint32 country = 2;
+    if (has_country()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->country());
+    }
+
+    // optional string city = 3;
+    if (has_city()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->city());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameSessionLocation::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameSessionLocation* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameSessionLocation*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameSessionLocation::MergeFrom(const GameSessionLocation& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_ip_address()) {
+      set_ip_address(from.ip_address());
+    }
+    if (from.has_country()) {
+      set_country(from.country());
+    }
+    if (from.has_city()) {
+      set_city(from.city());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameSessionLocation::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameSessionLocation::CopyFrom(const GameSessionLocation& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameSessionLocation::IsInitialized() const {
+
+  return true;
+}
+
+void GameSessionLocation::Swap(GameSessionLocation* other) {
+  if (other != this) {
+    std::swap(ip_address_, other->ip_address_);
+    std::swap(country_, other->country_);
+    std::swap(city_, other->city_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameSessionLocation::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameSessionLocation_descriptor_;
+  metadata.reflection = GameSessionLocation_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int CAIS::kPlayedMinutesFieldNumber;
+const int CAIS::kRestedMinutesFieldNumber;
+const int CAIS::kLastHeardTimeFieldNumber;
+#endif  // !_MSC_VER
+
+CAIS::CAIS()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.CAIS)
+}
+
+void CAIS::InitAsDefaultInstance() {
+}
+
+CAIS::CAIS(const CAIS& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.CAIS)
+}
+
+void CAIS::SharedCtor() {
+  _cached_size_ = 0;
+  played_minutes_ = 0u;
+  rested_minutes_ = 0u;
+  last_heard_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+CAIS::~CAIS() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.CAIS)
+  SharedDtor();
+}
+
+void CAIS::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void CAIS::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* CAIS::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return CAIS_descriptor_;
+}
+
+const CAIS& CAIS::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+CAIS* CAIS::default_instance_ = NULL;
+
+CAIS* CAIS::New() const {
+  return new CAIS;
+}
+
+void CAIS::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<CAIS*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(played_minutes_, last_heard_time_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool CAIS::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.CAIS)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 played_minutes = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &played_minutes_)));
+          set_has_played_minutes();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_rested_minutes;
+        break;
+      }
+
+      // optional uint32 rested_minutes = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_rested_minutes:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &rested_minutes_)));
+          set_has_rested_minutes();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_last_heard_time;
+        break;
+      }
+
+      // optional uint64 last_heard_time = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_last_heard_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &last_heard_time_)));
+          set_has_last_heard_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.CAIS)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.CAIS)
+  return false;
+#undef DO_
+}
+
+void CAIS::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.CAIS)
+  // optional uint32 played_minutes = 1;
+  if (has_played_minutes()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->played_minutes(), output);
+  }
+
+  // optional uint32 rested_minutes = 2;
+  if (has_rested_minutes()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->rested_minutes(), output);
+  }
+
+  // optional uint64 last_heard_time = 3;
+  if (has_last_heard_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->last_heard_time(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.CAIS)
+}
+
+::google::protobuf::uint8* CAIS::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.CAIS)
+  // optional uint32 played_minutes = 1;
+  if (has_played_minutes()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->played_minutes(), target);
+  }
+
+  // optional uint32 rested_minutes = 2;
+  if (has_rested_minutes()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->rested_minutes(), target);
+  }
+
+  // optional uint64 last_heard_time = 3;
+  if (has_last_heard_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->last_heard_time(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.CAIS)
+  return target;
+}
+
+int CAIS::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 played_minutes = 1;
+    if (has_played_minutes()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->played_minutes());
+    }
+
+    // optional uint32 rested_minutes = 2;
+    if (has_rested_minutes()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->rested_minutes());
+    }
+
+    // optional uint64 last_heard_time = 3;
+    if (has_last_heard_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->last_heard_time());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void CAIS::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const CAIS* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const CAIS*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void CAIS::MergeFrom(const CAIS& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_played_minutes()) {
+      set_played_minutes(from.played_minutes());
+    }
+    if (from.has_rested_minutes()) {
+      set_rested_minutes(from.rested_minutes());
+    }
+    if (from.has_last_heard_time()) {
+      set_last_heard_time(from.last_heard_time());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void CAIS::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void CAIS::CopyFrom(const CAIS& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool CAIS::IsInitialized() const {
+
+  return true;
+}
+
+void CAIS::Swap(CAIS* other) {
+  if (other != this) {
+    std::swap(played_minutes_, other->played_minutes_);
+    std::swap(rested_minutes_, other->rested_minutes_);
+    std::swap(last_heard_time_, other->last_heard_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata CAIS::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = CAIS_descriptor_;
+  metadata.reflection = CAIS_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameAccountList::kRegionFieldNumber;
+const int GameAccountList::kHandleFieldNumber;
+#endif  // !_MSC_VER
+
+GameAccountList::GameAccountList()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountList)
+}
+
+void GameAccountList::InitAsDefaultInstance() {
+}
+
+GameAccountList::GameAccountList(const GameAccountList& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountList)
+}
+
+void GameAccountList::SharedCtor() {
+  _cached_size_ = 0;
+  region_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameAccountList::~GameAccountList() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountList)
+  SharedDtor();
+}
+
+void GameAccountList::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GameAccountList::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameAccountList::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameAccountList_descriptor_;
+}
+
+const GameAccountList& GameAccountList::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GameAccountList* GameAccountList::default_instance_ = NULL;
+
+GameAccountList* GameAccountList::New() const {
+  return new GameAccountList;
+}
+
+void GameAccountList::Clear() {
+  region_ = 0u;
+  handle_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameAccountList::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountList)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 region = 3;
+      case 3: {
+        if (tag == 24) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &region_)));
+          set_has_region();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_handle;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.GameAccountHandle handle = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_handle:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_handle()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_handle;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameAccountList)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountList)
+  return false;
+#undef DO_
+}
+
+void GameAccountList::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountList)
+  // optional uint32 region = 3;
+  if (has_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->region(), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.GameAccountHandle handle = 4;
+  for (int i = 0; i < this->handle_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->handle(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountList)
+}
+
+::google::protobuf::uint8* GameAccountList::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountList)
+  // optional uint32 region = 3;
+  if (has_region()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->region(), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.GameAccountHandle handle = 4;
+  for (int i = 0; i < this->handle_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->handle(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountList)
+  return target;
+}
+
+int GameAccountList::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 region = 3;
+    if (has_region()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->region());
+    }
+
+  }
+  // repeated .bgs.protocol.account.v1.GameAccountHandle handle = 4;
+  total_size += 1 * this->handle_size();
+  for (int i = 0; i < this->handle_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->handle(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameAccountList::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameAccountList* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountList*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameAccountList::MergeFrom(const GameAccountList& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  handle_.MergeFrom(from.handle_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_region()) {
+      set_region(from.region());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameAccountList::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameAccountList::CopyFrom(const GameAccountList& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameAccountList::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->handle())) return false;
+  return true;
+}
+
+void GameAccountList::Swap(GameAccountList* other) {
+  if (other != this) {
+    std::swap(region_, other->region_);
+    handle_.Swap(&other->handle_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameAccountList::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameAccountList_descriptor_;
+  metadata.reflection = GameAccountList_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountState::kAccountLevelInfoFieldNumber;
+const int AccountState::kPrivacyInfoFieldNumber;
+const int AccountState::kParentalControlInfoFieldNumber;
+const int AccountState::kGameLevelInfoFieldNumber;
+const int AccountState::kGameStatusFieldNumber;
+const int AccountState::kGameAccountsFieldNumber;
+#endif  // !_MSC_VER
+
+AccountState::AccountState()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountState)
+}
+
+void AccountState::InitAsDefaultInstance() {
+  account_level_info_ = const_cast< ::bgs::protocol::account::v1::AccountLevelInfo*>(&::bgs::protocol::account::v1::AccountLevelInfo::default_instance());
+  privacy_info_ = const_cast< ::bgs::protocol::account::v1::PrivacyInfo*>(&::bgs::protocol::account::v1::PrivacyInfo::default_instance());
+  parental_control_info_ = const_cast< ::bgs::protocol::account::v1::ParentalControlInfo*>(&::bgs::protocol::account::v1::ParentalControlInfo::default_instance());
+}
+
+AccountState::AccountState(const AccountState& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountState)
+}
+
+void AccountState::SharedCtor() {
+  _cached_size_ = 0;
+  account_level_info_ = NULL;
+  privacy_info_ = NULL;
+  parental_control_info_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountState::~AccountState() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountState)
+  SharedDtor();
+}
+
+void AccountState::SharedDtor() {
+  if (this != default_instance_) {
+    delete account_level_info_;
+    delete privacy_info_;
+    delete parental_control_info_;
+  }
+}
+
+void AccountState::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountState::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountState_descriptor_;
+}
+
+const AccountState& AccountState::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+AccountState* AccountState::default_instance_ = NULL;
+
+AccountState* AccountState::New() const {
+  return new AccountState;
+}
+
+void AccountState::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_account_level_info()) {
+      if (account_level_info_ != NULL) account_level_info_->::bgs::protocol::account::v1::AccountLevelInfo::Clear();
+    }
+    if (has_privacy_info()) {
+      if (privacy_info_ != NULL) privacy_info_->::bgs::protocol::account::v1::PrivacyInfo::Clear();
+    }
+    if (has_parental_control_info()) {
+      if (parental_control_info_ != NULL) parental_control_info_->::bgs::protocol::account::v1::ParentalControlInfo::Clear();
+    }
+  }
+  game_level_info_.Clear();
+  game_status_.Clear();
+  game_accounts_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountState::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountState)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountLevelInfo account_level_info = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_level_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_privacy_info;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.PrivacyInfo privacy_info = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_privacy_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_privacy_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_parental_control_info;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_parental_control_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_parental_control_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_game_level_info;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.GameLevelInfo game_level_info = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_game_level_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_game_level_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_game_level_info;
+        if (input->ExpectTag(50)) goto parse_game_status;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.GameStatus game_status = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_game_status:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_game_status()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_game_status;
+        if (input->ExpectTag(58)) goto parse_game_accounts;
+        break;
+      }
+
+      // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_game_accounts:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_game_accounts()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_game_accounts;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountState)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountState)
+  return false;
+#undef DO_
+}
+
+void AccountState::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountState)
+  // optional .bgs.protocol.account.v1.AccountLevelInfo account_level_info = 1;
+  if (has_account_level_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->account_level_info(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.PrivacyInfo privacy_info = 2;
+  if (has_privacy_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->privacy_info(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 3;
+  if (has_parental_control_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->parental_control_info(), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.GameLevelInfo game_level_info = 5;
+  for (int i = 0; i < this->game_level_info_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->game_level_info(i), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.GameStatus game_status = 6;
+  for (int i = 0; i < this->game_status_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->game_status(i), output);
+  }
+
+  // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 7;
+  for (int i = 0; i < this->game_accounts_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      7, this->game_accounts(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountState)
+}
+
+::google::protobuf::uint8* AccountState::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountState)
+  // optional .bgs.protocol.account.v1.AccountLevelInfo account_level_info = 1;
+  if (has_account_level_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->account_level_info(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.PrivacyInfo privacy_info = 2;
+  if (has_privacy_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->privacy_info(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 3;
+  if (has_parental_control_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->parental_control_info(), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.GameLevelInfo game_level_info = 5;
+  for (int i = 0; i < this->game_level_info_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->game_level_info(i), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.GameStatus game_status = 6;
+  for (int i = 0; i < this->game_status_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->game_status(i), target);
+  }
+
+  // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 7;
+  for (int i = 0; i < this->game_accounts_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        7, this->game_accounts(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountState)
+  return target;
+}
+
+int AccountState::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountLevelInfo account_level_info = 1;
+    if (has_account_level_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_level_info());
+    }
+
+    // optional .bgs.protocol.account.v1.PrivacyInfo privacy_info = 2;
+    if (has_privacy_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->privacy_info());
+    }
+
+    // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 3;
+    if (has_parental_control_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->parental_control_info());
+    }
+
+  }
+  // repeated .bgs.protocol.account.v1.GameLevelInfo game_level_info = 5;
+  total_size += 1 * this->game_level_info_size();
+  for (int i = 0; i < this->game_level_info_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->game_level_info(i));
+  }
+
+  // repeated .bgs.protocol.account.v1.GameStatus game_status = 6;
+  total_size += 1 * this->game_status_size();
+  for (int i = 0; i < this->game_status_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->game_status(i));
+  }
+
+  // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 7;
+  total_size += 1 * this->game_accounts_size();
+  for (int i = 0; i < this->game_accounts_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->game_accounts(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountState::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountState* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountState*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountState::MergeFrom(const AccountState& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  game_level_info_.MergeFrom(from.game_level_info_);
+  game_status_.MergeFrom(from.game_status_);
+  game_accounts_.MergeFrom(from.game_accounts_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account_level_info()) {
+      mutable_account_level_info()->::bgs::protocol::account::v1::AccountLevelInfo::MergeFrom(from.account_level_info());
+    }
+    if (from.has_privacy_info()) {
+      mutable_privacy_info()->::bgs::protocol::account::v1::PrivacyInfo::MergeFrom(from.privacy_info());
+    }
+    if (from.has_parental_control_info()) {
+      mutable_parental_control_info()->::bgs::protocol::account::v1::ParentalControlInfo::MergeFrom(from.parental_control_info());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountState::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountState::CopyFrom(const AccountState& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountState::IsInitialized() const {
+
+  if (has_account_level_info()) {
+    if (!this->account_level_info().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->game_level_info())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->game_accounts())) return false;
+  return true;
+}
+
+void AccountState::Swap(AccountState* other) {
+  if (other != this) {
+    std::swap(account_level_info_, other->account_level_info_);
+    std::swap(privacy_info_, other->privacy_info_);
+    std::swap(parental_control_info_, other->parental_control_info_);
+    game_level_info_.Swap(&other->game_level_info_);
+    game_status_.Swap(&other->game_status_);
+    game_accounts_.Swap(&other->game_accounts_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountState::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountState_descriptor_;
+  metadata.reflection = AccountState_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountStateTagged::kAccountStateFieldNumber;
+const int AccountStateTagged::kAccountTagsFieldNumber;
+#endif  // !_MSC_VER
+
+AccountStateTagged::AccountStateTagged()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AccountStateTagged)
+}
+
+void AccountStateTagged::InitAsDefaultInstance() {
+  account_state_ = const_cast< ::bgs::protocol::account::v1::AccountState*>(&::bgs::protocol::account::v1::AccountState::default_instance());
+  account_tags_ = const_cast< ::bgs::protocol::account::v1::AccountFieldTags*>(&::bgs::protocol::account::v1::AccountFieldTags::default_instance());
+}
+
+AccountStateTagged::AccountStateTagged(const AccountStateTagged& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AccountStateTagged)
+}
+
+void AccountStateTagged::SharedCtor() {
+  _cached_size_ = 0;
+  account_state_ = NULL;
+  account_tags_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountStateTagged::~AccountStateTagged() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AccountStateTagged)
+  SharedDtor();
+}
+
+void AccountStateTagged::SharedDtor() {
+  if (this != default_instance_) {
+    delete account_state_;
+    delete account_tags_;
+  }
+}
+
+void AccountStateTagged::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountStateTagged::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountStateTagged_descriptor_;
+}
+
+const AccountStateTagged& AccountStateTagged::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+AccountStateTagged* AccountStateTagged::default_instance_ = NULL;
+
+AccountStateTagged* AccountStateTagged::New() const {
+  return new AccountStateTagged;
+}
+
+void AccountStateTagged::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_account_state()) {
+      if (account_state_ != NULL) account_state_->::bgs::protocol::account::v1::AccountState::Clear();
+    }
+    if (has_account_tags()) {
+      if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountStateTagged::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AccountStateTagged)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.AccountState account_state = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_account_tags;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_account_tags:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_tags()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AccountStateTagged)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AccountStateTagged)
+  return false;
+#undef DO_
+}
+
+void AccountStateTagged::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AccountStateTagged)
+  // optional .bgs.protocol.account.v1.AccountState account_state = 1;
+  if (has_account_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->account_state(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 2;
+  if (has_account_tags()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->account_tags(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AccountStateTagged)
+}
+
+::google::protobuf::uint8* AccountStateTagged::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AccountStateTagged)
+  // optional .bgs.protocol.account.v1.AccountState account_state = 1;
+  if (has_account_state()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->account_state(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 2;
+  if (has_account_tags()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->account_tags(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AccountStateTagged)
+  return target;
+}
+
+int AccountStateTagged::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.AccountState account_state = 1;
+    if (has_account_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_state());
+    }
+
+    // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 2;
+    if (has_account_tags()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_tags());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountStateTagged::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountStateTagged* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountStateTagged*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountStateTagged::MergeFrom(const AccountStateTagged& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account_state()) {
+      mutable_account_state()->::bgs::protocol::account::v1::AccountState::MergeFrom(from.account_state());
+    }
+    if (from.has_account_tags()) {
+      mutable_account_tags()->::bgs::protocol::account::v1::AccountFieldTags::MergeFrom(from.account_tags());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountStateTagged::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountStateTagged::CopyFrom(const AccountStateTagged& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountStateTagged::IsInitialized() const {
+
+  if (has_account_state()) {
+    if (!this->account_state().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AccountStateTagged::Swap(AccountStateTagged* other) {
+  if (other != this) {
+    std::swap(account_state_, other->account_state_);
+    std::swap(account_tags_, other->account_tags_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountStateTagged::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountStateTagged_descriptor_;
+  metadata.reflection = AccountStateTagged_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameAccountState::kGameLevelInfoFieldNumber;
+const int GameAccountState::kGameTimeInfoFieldNumber;
+const int GameAccountState::kGameStatusFieldNumber;
+const int GameAccountState::kRafInfoFieldNumber;
+#endif  // !_MSC_VER
+
+GameAccountState::GameAccountState()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountState)
+}
+
+void GameAccountState::InitAsDefaultInstance() {
+  game_level_info_ = const_cast< ::bgs::protocol::account::v1::GameLevelInfo*>(&::bgs::protocol::account::v1::GameLevelInfo::default_instance());
+  game_time_info_ = const_cast< ::bgs::protocol::account::v1::GameTimeInfo*>(&::bgs::protocol::account::v1::GameTimeInfo::default_instance());
+  game_status_ = const_cast< ::bgs::protocol::account::v1::GameStatus*>(&::bgs::protocol::account::v1::GameStatus::default_instance());
+  raf_info_ = const_cast< ::bgs::protocol::account::v1::RAFInfo*>(&::bgs::protocol::account::v1::RAFInfo::default_instance());
+}
+
+GameAccountState::GameAccountState(const GameAccountState& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountState)
+}
+
+void GameAccountState::SharedCtor() {
+  _cached_size_ = 0;
+  game_level_info_ = NULL;
+  game_time_info_ = NULL;
+  game_status_ = NULL;
+  raf_info_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameAccountState::~GameAccountState() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountState)
+  SharedDtor();
+}
+
+void GameAccountState::SharedDtor() {
+  if (this != default_instance_) {
+    delete game_level_info_;
+    delete game_time_info_;
+    delete game_status_;
+    delete raf_info_;
+  }
+}
+
+void GameAccountState::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameAccountState::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameAccountState_descriptor_;
+}
+
+const GameAccountState& GameAccountState::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GameAccountState* GameAccountState::default_instance_ = NULL;
+
+GameAccountState* GameAccountState::New() const {
+  return new GameAccountState;
+}
+
+void GameAccountState::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_game_level_info()) {
+      if (game_level_info_ != NULL) game_level_info_->::bgs::protocol::account::v1::GameLevelInfo::Clear();
+    }
+    if (has_game_time_info()) {
+      if (game_time_info_ != NULL) game_time_info_->::bgs::protocol::account::v1::GameTimeInfo::Clear();
+    }
+    if (has_game_status()) {
+      if (game_status_ != NULL) game_status_->::bgs::protocol::account::v1::GameStatus::Clear();
+    }
+    if (has_raf_info()) {
+      if (raf_info_ != NULL) raf_info_->::bgs::protocol::account::v1::RAFInfo::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameAccountState::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountState)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.GameLevelInfo game_level_info = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_level_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_game_time_info;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.GameTimeInfo game_time_info = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_game_time_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_time_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_game_status;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.GameStatus game_status = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_game_status:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_status()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_raf_info;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.RAFInfo raf_info = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_raf_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_raf_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameAccountState)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountState)
+  return false;
+#undef DO_
+}
+
+void GameAccountState::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountState)
+  // optional .bgs.protocol.account.v1.GameLevelInfo game_level_info = 1;
+  if (has_game_level_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->game_level_info(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.GameTimeInfo game_time_info = 2;
+  if (has_game_time_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->game_time_info(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.GameStatus game_status = 3;
+  if (has_game_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->game_status(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.RAFInfo raf_info = 4;
+  if (has_raf_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->raf_info(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountState)
+}
+
+::google::protobuf::uint8* GameAccountState::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountState)
+  // optional .bgs.protocol.account.v1.GameLevelInfo game_level_info = 1;
+  if (has_game_level_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->game_level_info(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.GameTimeInfo game_time_info = 2;
+  if (has_game_time_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->game_time_info(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.GameStatus game_status = 3;
+  if (has_game_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->game_status(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.RAFInfo raf_info = 4;
+  if (has_raf_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->raf_info(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountState)
+  return target;
+}
+
+int GameAccountState::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.GameLevelInfo game_level_info = 1;
+    if (has_game_level_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_level_info());
+    }
+
+    // optional .bgs.protocol.account.v1.GameTimeInfo game_time_info = 2;
+    if (has_game_time_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_time_info());
+    }
+
+    // optional .bgs.protocol.account.v1.GameStatus game_status = 3;
+    if (has_game_status()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_status());
+    }
+
+    // optional .bgs.protocol.account.v1.RAFInfo raf_info = 4;
+    if (has_raf_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->raf_info());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameAccountState::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameAccountState* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountState*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameAccountState::MergeFrom(const GameAccountState& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_game_level_info()) {
+      mutable_game_level_info()->::bgs::protocol::account::v1::GameLevelInfo::MergeFrom(from.game_level_info());
+    }
+    if (from.has_game_time_info()) {
+      mutable_game_time_info()->::bgs::protocol::account::v1::GameTimeInfo::MergeFrom(from.game_time_info());
+    }
+    if (from.has_game_status()) {
+      mutable_game_status()->::bgs::protocol::account::v1::GameStatus::MergeFrom(from.game_status());
+    }
+    if (from.has_raf_info()) {
+      mutable_raf_info()->::bgs::protocol::account::v1::RAFInfo::MergeFrom(from.raf_info());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameAccountState::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameAccountState::CopyFrom(const GameAccountState& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameAccountState::IsInitialized() const {
+
+  if (has_game_level_info()) {
+    if (!this->game_level_info().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GameAccountState::Swap(GameAccountState* other) {
+  if (other != this) {
+    std::swap(game_level_info_, other->game_level_info_);
+    std::swap(game_time_info_, other->game_time_info_);
+    std::swap(game_status_, other->game_status_);
+    std::swap(raf_info_, other->raf_info_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameAccountState::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameAccountState_descriptor_;
+  metadata.reflection = GameAccountState_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameAccountStateTagged::kGameAccountStateFieldNumber;
+const int GameAccountStateTagged::kGameAccountTagsFieldNumber;
+#endif  // !_MSC_VER
+
+GameAccountStateTagged::GameAccountStateTagged()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.GameAccountStateTagged)
+}
+
+void GameAccountStateTagged::InitAsDefaultInstance() {
+  game_account_state_ = const_cast< ::bgs::protocol::account::v1::GameAccountState*>(&::bgs::protocol::account::v1::GameAccountState::default_instance());
+  game_account_tags_ = const_cast< ::bgs::protocol::account::v1::GameAccountFieldTags*>(&::bgs::protocol::account::v1::GameAccountFieldTags::default_instance());
+}
+
+GameAccountStateTagged::GameAccountStateTagged(const GameAccountStateTagged& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.GameAccountStateTagged)
+}
+
+void GameAccountStateTagged::SharedCtor() {
+  _cached_size_ = 0;
+  game_account_state_ = NULL;
+  game_account_tags_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameAccountStateTagged::~GameAccountStateTagged() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.GameAccountStateTagged)
+  SharedDtor();
+}
+
+void GameAccountStateTagged::SharedDtor() {
+  if (this != default_instance_) {
+    delete game_account_state_;
+    delete game_account_tags_;
+  }
+}
+
+void GameAccountStateTagged::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameAccountStateTagged::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameAccountStateTagged_descriptor_;
+}
+
+const GameAccountStateTagged& GameAccountStateTagged::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GameAccountStateTagged* GameAccountStateTagged::default_instance_ = NULL;
+
+GameAccountStateTagged* GameAccountStateTagged::New() const {
+  return new GameAccountStateTagged;
+}
+
+void GameAccountStateTagged::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_game_account_state()) {
+      if (game_account_state_ != NULL) game_account_state_->::bgs::protocol::account::v1::GameAccountState::Clear();
+    }
+    if (has_game_account_tags()) {
+      if (game_account_tags_ != NULL) game_account_tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameAccountStateTagged::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.GameAccountStateTagged)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_game_account_tags;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_game_account_tags:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_tags()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.GameAccountStateTagged)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.GameAccountStateTagged)
+  return false;
+#undef DO_
+}
+
+void GameAccountStateTagged::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.GameAccountStateTagged)
+  // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1;
+  if (has_game_account_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->game_account_state(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 2;
+  if (has_game_account_tags()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->game_account_tags(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.GameAccountStateTagged)
+}
+
+::google::protobuf::uint8* GameAccountStateTagged::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.GameAccountStateTagged)
+  // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1;
+  if (has_game_account_state()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->game_account_state(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 2;
+  if (has_game_account_tags()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->game_account_tags(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.GameAccountStateTagged)
+  return target;
+}
+
+int GameAccountStateTagged::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1;
+    if (has_game_account_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_state());
+    }
+
+    // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 2;
+    if (has_game_account_tags()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_tags());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameAccountStateTagged::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameAccountStateTagged* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountStateTagged*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameAccountStateTagged::MergeFrom(const GameAccountStateTagged& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_game_account_state()) {
+      mutable_game_account_state()->::bgs::protocol::account::v1::GameAccountState::MergeFrom(from.game_account_state());
+    }
+    if (from.has_game_account_tags()) {
+      mutable_game_account_tags()->::bgs::protocol::account::v1::GameAccountFieldTags::MergeFrom(from.game_account_tags());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameAccountStateTagged::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameAccountStateTagged::CopyFrom(const GameAccountStateTagged& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameAccountStateTagged::IsInitialized() const {
+
+  if (has_game_account_state()) {
+    if (!this->game_account_state().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GameAccountStateTagged::Swap(GameAccountStateTagged* other) {
+  if (other != this) {
+    std::swap(game_account_state_, other->game_account_state_);
+    std::swap(game_account_tags_, other->game_account_tags_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameAccountStateTagged::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameAccountStateTagged_descriptor_;
+  metadata.reflection = GameAccountStateTagged_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AuthorizedData::kDataFieldNumber;
+const int AuthorizedData::kLicenseFieldNumber;
+#endif  // !_MSC_VER
+
+AuthorizedData::AuthorizedData()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.account.v1.AuthorizedData)
+}
+
+void AuthorizedData::InitAsDefaultInstance() {
+}
+
+AuthorizedData::AuthorizedData(const AuthorizedData& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.account.v1.AuthorizedData)
+}
+
+void AuthorizedData::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AuthorizedData::~AuthorizedData() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.account.v1.AuthorizedData)
+  SharedDtor();
+}
+
+void AuthorizedData::SharedDtor() {
+  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete data_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void AuthorizedData::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AuthorizedData::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AuthorizedData_descriptor_;
+}
+
+const AuthorizedData& AuthorizedData::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_account_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+AuthorizedData* AuthorizedData::default_instance_ = NULL;
+
+AuthorizedData* AuthorizedData::New() const {
+  return new AuthorizedData;
+}
+
+void AuthorizedData::Clear() {
+  if (has_data()) {
+    if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      data_->clear();
+    }
+  }
+  license_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AuthorizedData::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.account.v1.AuthorizedData)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string data = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_data()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->data().data(), this->data().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "data");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_license;
+        break;
+      }
+
+      // repeated uint32 license = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_license:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 16, input, this->mutable_license())));
+        } else if (tag == 18) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_license())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_license;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.account.v1.AuthorizedData)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.account.v1.AuthorizedData)
+  return false;
+#undef DO_
+}
+
+void AuthorizedData::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.account.v1.AuthorizedData)
+  // optional string data = 1;
+  if (has_data()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->data().data(), this->data().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "data");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->data(), output);
+  }
+
+  // repeated uint32 license = 2;
+  for (int i = 0; i < this->license_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
+      2, this->license(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.account.v1.AuthorizedData)
+}
+
+::google::protobuf::uint8* AuthorizedData::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.account.v1.AuthorizedData)
+  // optional string data = 1;
+  if (has_data()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->data().data(), this->data().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "data");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->data(), target);
+  }
+
+  // repeated uint32 license = 2;
+  for (int i = 0; i < this->license_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32ToArray(2, this->license(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.account.v1.AuthorizedData)
+  return target;
+}
+
+int AuthorizedData::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string data = 1;
+    if (has_data()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->data());
+    }
+
+  }
+  // repeated uint32 license = 2;
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->license_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->license(i));
+    }
+    total_size += 1 * this->license_size() + data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AuthorizedData::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AuthorizedData* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AuthorizedData*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AuthorizedData::MergeFrom(const AuthorizedData& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  license_.MergeFrom(from.license_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_data()) {
+      set_data(from.data());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AuthorizedData::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AuthorizedData::CopyFrom(const AuthorizedData& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AuthorizedData::IsInitialized() const {
+
+  return true;
+}
+
+void AuthorizedData::Swap(AuthorizedData* other) {
+  if (other != this) {
+    std::swap(data_, other->data_);
+    license_.Swap(&other->license_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AuthorizedData::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AuthorizedData_descriptor_;
+  metadata.reflection = AuthorizedData_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace account
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/account_types.pb.h b/src/server/proto/Client/account_types.pb.h
new file mode 100644
index 00000000000..f1cc923d30d
--- /dev/null
+++ b/src/server/proto/Client/account_types.pb.h
@@ -0,0 +1,10138 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: account_types.proto
+
+#ifndef PROTOBUF_account_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_account_5ftypes_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/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "entity_types.pb.h"
+#include "rpc_types.pb.h"
+#include "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace account {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+void protobuf_AssignDesc_account_5ftypes_2eproto();
+void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+class AccountId;
+class AccountLicense;
+class AccountCredential;
+class AccountBlob;
+class AccountBlobList;
+class GameAccountHandle;
+class GameAccountLink;
+class GameAccountBlob;
+class GameAccountBlobList;
+class AccountReference;
+class Identity;
+class ProgramTag;
+class RegionTag;
+class AccountFieldTags;
+class GameAccountFieldTags;
+class AccountFieldOptions;
+class GameAccountFieldOptions;
+class SubscriberReference;
+class AccountLevelInfo;
+class PrivacyInfo;
+class ParentalControlInfo;
+class GameLevelInfo;
+class GameTimeInfo;
+class GameTimeRemainingInfo;
+class GameStatus;
+class RAFInfo;
+class GameSessionInfo;
+class GameSessionUpdateInfo;
+class GameSessionLocation;
+class CAIS;
+class GameAccountList;
+class AccountState;
+class AccountStateTagged;
+class GameAccountState;
+class GameAccountStateTagged;
+class AuthorizedData;
+
+enum PrivacyInfo_GameInfoPrivacy {
+  PrivacyInfo_GameInfoPrivacy_PRIVACY_ME = 0,
+  PrivacyInfo_GameInfoPrivacy_PRIVACY_FRIENDS = 1,
+  PrivacyInfo_GameInfoPrivacy_PRIVACY_EVERYONE = 2
+};
+TC_SHARED_API bool PrivacyInfo_GameInfoPrivacy_IsValid(int value);
+const PrivacyInfo_GameInfoPrivacy PrivacyInfo_GameInfoPrivacy_GameInfoPrivacy_MIN = PrivacyInfo_GameInfoPrivacy_PRIVACY_ME;
+const PrivacyInfo_GameInfoPrivacy PrivacyInfo_GameInfoPrivacy_GameInfoPrivacy_MAX = PrivacyInfo_GameInfoPrivacy_PRIVACY_EVERYONE;
+const int PrivacyInfo_GameInfoPrivacy_GameInfoPrivacy_ARRAYSIZE = PrivacyInfo_GameInfoPrivacy_GameInfoPrivacy_MAX + 1;
+
+TC_SHARED_API const ::google::protobuf::EnumDescriptor* PrivacyInfo_GameInfoPrivacy_descriptor();
+inline const ::std::string& PrivacyInfo_GameInfoPrivacy_Name(PrivacyInfo_GameInfoPrivacy value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    PrivacyInfo_GameInfoPrivacy_descriptor(), value);
+}
+inline bool PrivacyInfo_GameInfoPrivacy_Parse(
+    const ::std::string& name, PrivacyInfo_GameInfoPrivacy* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<PrivacyInfo_GameInfoPrivacy>(
+    PrivacyInfo_GameInfoPrivacy_descriptor(), name, value);
+}
+enum IdentityVerificationStatus {
+  IDENT_NO_DATA = 0,
+  IDENT_PENDING = 1,
+  IDENT_FAILED = 4,
+  IDENT_SUCCESS = 5,
+  IDENT_SUCC_MNL = 6,
+  IDENT_UNKNOWN = 7
+};
+TC_SHARED_API bool IdentityVerificationStatus_IsValid(int value);
+const IdentityVerificationStatus IdentityVerificationStatus_MIN = IDENT_NO_DATA;
+const IdentityVerificationStatus IdentityVerificationStatus_MAX = IDENT_UNKNOWN;
+const int IdentityVerificationStatus_ARRAYSIZE = IdentityVerificationStatus_MAX + 1;
+
+TC_SHARED_API const ::google::protobuf::EnumDescriptor* IdentityVerificationStatus_descriptor();
+inline const ::std::string& IdentityVerificationStatus_Name(IdentityVerificationStatus value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    IdentityVerificationStatus_descriptor(), value);
+}
+inline bool IdentityVerificationStatus_Parse(
+    const ::std::string& name, IdentityVerificationStatus* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<IdentityVerificationStatus>(
+    IdentityVerificationStatus_descriptor(), name, value);
+}
+// ===================================================================
+
+class TC_SHARED_API AccountId : public ::google::protobuf::Message {
+ public:
+  AccountId();
+  virtual ~AccountId();
+
+  AccountId(const AccountId& from);
+
+  inline AccountId& operator=(const AccountId& 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 AccountId& default_instance();
+
+  void Swap(AccountId* other);
+
+  // implements Message ----------------------------------------------
+
+  AccountId* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AccountId& from);
+  void MergeFrom(const AccountId& 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 fixed32 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountId)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 id_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static AccountId* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AccountLicense : public ::google::protobuf::Message {
+ public:
+  AccountLicense();
+  virtual ~AccountLicense();
+
+  AccountLicense(const AccountLicense& from);
+
+  inline AccountLicense& operator=(const AccountLicense& 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 AccountLicense& default_instance();
+
+  void Swap(AccountLicense* other);
+
+  // implements Message ----------------------------------------------
+
+  AccountLicense* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AccountLicense& from);
+  void MergeFrom(const AccountLicense& 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 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // optional uint64 expires = 2;
+  inline bool has_expires() const;
+  inline void clear_expires();
+  static const int kExpiresFieldNumber = 2;
+  inline ::google::protobuf::uint64 expires() const;
+  inline void set_expires(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountLicense)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_expires();
+  inline void clear_has_expires();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 expires_;
+  ::google::protobuf::uint32 id_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static AccountLicense* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AccountCredential : public ::google::protobuf::Message {
+ public:
+  AccountCredential();
+  virtual ~AccountCredential();
+
+  AccountCredential(const AccountCredential& from);
+
+  inline AccountCredential& operator=(const AccountCredential& 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 AccountCredential& default_instance();
+
+  void Swap(AccountCredential* other);
+
+  // implements Message ----------------------------------------------
+
+  AccountCredential* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AccountCredential& from);
+  void MergeFrom(const AccountCredential& 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 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // optional bytes data = 2;
+  inline bool has_data() const;
+  inline void clear_data();
+  static const int kDataFieldNumber = 2;
+  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.account.v1.AccountCredential)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  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_;
+  ::google::protobuf::uint32 id_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static AccountCredential* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AccountBlob : public ::google::protobuf::Message {
+ public:
+  AccountBlob();
+  virtual ~AccountBlob();
+
+  AccountBlob(const AccountBlob& from);
+
+  inline AccountBlob& operator=(const AccountBlob& 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 AccountBlob& default_instance();
+
+  void Swap(AccountBlob* other);
+
+  // implements Message ----------------------------------------------
+
+  AccountBlob* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AccountBlob& from);
+  void MergeFrom(const AccountBlob& 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 fixed32 id = 2;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 2;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // required uint32 region = 3;
+  inline bool has_region() const;
+  inline void clear_region();
+  static const int kRegionFieldNumber = 3;
+  inline ::google::protobuf::uint32 region() const;
+  inline void set_region(::google::protobuf::uint32 value);
+
+  // repeated string email = 4;
+  inline int email_size() const;
+  inline void clear_email();
+  static const int kEmailFieldNumber = 4;
+  inline const ::std::string& email(int index) const;
+  inline ::std::string* mutable_email(int index);
+  inline void set_email(int index, const ::std::string& value);
+  inline void set_email(int index, const char* value);
+  inline void set_email(int index, const char* value, size_t size);
+  inline ::std::string* add_email();
+  inline void add_email(const ::std::string& value);
+  inline void add_email(const char* value);
+  inline void add_email(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& email() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_email();
+
+  // required uint64 flags = 5;
+  inline bool has_flags() const;
+  inline void clear_flags();
+  static const int kFlagsFieldNumber = 5;
+  inline ::google::protobuf::uint64 flags() const;
+  inline void set_flags(::google::protobuf::uint64 value);
+
+  // optional uint64 secure_release = 6;
+  inline bool has_secure_release() const;
+  inline void clear_secure_release();
+  static const int kSecureReleaseFieldNumber = 6;
+  inline ::google::protobuf::uint64 secure_release() const;
+  inline void set_secure_release(::google::protobuf::uint64 value);
+
+  // optional uint64 whitelist_start = 7;
+  inline bool has_whitelist_start() const;
+  inline void clear_whitelist_start();
+  static const int kWhitelistStartFieldNumber = 7;
+  inline ::google::protobuf::uint64 whitelist_start() const;
+  inline void set_whitelist_start(::google::protobuf::uint64 value);
+
+  // optional uint64 whitelist_end = 8;
+  inline bool has_whitelist_end() const;
+  inline void clear_whitelist_end();
+  static const int kWhitelistEndFieldNumber = 8;
+  inline ::google::protobuf::uint64 whitelist_end() const;
+  inline void set_whitelist_end(::google::protobuf::uint64 value);
+
+  // required string full_name = 10;
+  inline bool has_full_name() const;
+  inline void clear_full_name();
+  static const int kFullNameFieldNumber = 10;
+  inline const ::std::string& full_name() const;
+  inline void set_full_name(const ::std::string& value);
+  inline void set_full_name(const char* value);
+  inline void set_full_name(const char* value, size_t size);
+  inline ::std::string* mutable_full_name();
+  inline ::std::string* release_full_name();
+  inline void set_allocated_full_name(::std::string* full_name);
+
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
+  inline int licenses_size() const;
+  inline void clear_licenses();
+  static const int kLicensesFieldNumber = 20;
+  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();
+
+  // repeated .bgs.protocol.account.v1.AccountCredential credentials = 21;
+  inline int credentials_size() const;
+  inline void clear_credentials();
+  static const int kCredentialsFieldNumber = 21;
+  inline const ::bgs::protocol::account::v1::AccountCredential& credentials(int index) const;
+  inline ::bgs::protocol::account::v1::AccountCredential* mutable_credentials(int index);
+  inline ::bgs::protocol::account::v1::AccountCredential* add_credentials();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >&
+      credentials() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >*
+      mutable_credentials();
+
+  // repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22;
+  inline int account_links_size() const;
+  inline void clear_account_links();
+  static const int kAccountLinksFieldNumber = 22;
+  inline const ::bgs::protocol::account::v1::GameAccountLink& account_links(int index) const;
+  inline ::bgs::protocol::account::v1::GameAccountLink* mutable_account_links(int index);
+  inline ::bgs::protocol::account::v1::GameAccountLink* add_account_links();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >&
+      account_links() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >*
+      mutable_account_links();
+
+  // optional string battle_tag = 23;
+  inline bool has_battle_tag() const;
+  inline void clear_battle_tag();
+  static const int kBattleTagFieldNumber = 23;
+  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 fixed32 default_currency = 25;
+  inline bool has_default_currency() const;
+  inline void clear_default_currency();
+  static const int kDefaultCurrencyFieldNumber = 25;
+  inline ::google::protobuf::uint32 default_currency() const;
+  inline void set_default_currency(::google::protobuf::uint32 value);
+
+  // optional uint32 legal_region = 26;
+  inline bool has_legal_region() const;
+  inline void clear_legal_region();
+  static const int kLegalRegionFieldNumber = 26;
+  inline ::google::protobuf::uint32 legal_region() const;
+  inline void set_legal_region(::google::protobuf::uint32 value);
+
+  // optional fixed32 legal_locale = 27;
+  inline bool has_legal_locale() const;
+  inline void clear_legal_locale();
+  static const int kLegalLocaleFieldNumber = 27;
+  inline ::google::protobuf::uint32 legal_locale() const;
+  inline void set_legal_locale(::google::protobuf::uint32 value);
+
+  // required uint64 cache_expiration = 30;
+  inline bool has_cache_expiration() const;
+  inline void clear_cache_expiration();
+  static const int kCacheExpirationFieldNumber = 30;
+  inline ::google::protobuf::uint64 cache_expiration() const;
+  inline void set_cache_expiration(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31;
+  inline bool has_parental_control_info() const;
+  inline void clear_parental_control_info();
+  static const int kParentalControlInfoFieldNumber = 31;
+  inline const ::bgs::protocol::account::v1::ParentalControlInfo& parental_control_info() const;
+  inline ::bgs::protocol::account::v1::ParentalControlInfo* mutable_parental_control_info();
+  inline ::bgs::protocol::account::v1::ParentalControlInfo* release_parental_control_info();
+  inline void set_allocated_parental_control_info(::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info);
+
+  // optional string country = 32;
+  inline bool has_country() const;
+  inline void clear_country();
+  static const int kCountryFieldNumber = 32;
+  inline const ::std::string& country() const;
+  inline void set_country(const ::std::string& value);
+  inline void set_country(const char* value);
+  inline void set_country(const char* value, size_t size);
+  inline ::std::string* mutable_country();
+  inline ::std::string* release_country();
+  inline void set_allocated_country(::std::string* country);
+
+  // optional uint32 preferred_region = 33;
+  inline bool has_preferred_region() const;
+  inline void clear_preferred_region();
+  static const int kPreferredRegionFieldNumber = 33;
+  inline ::google::protobuf::uint32 preferred_region() const;
+  inline void set_preferred_region(::google::protobuf::uint32 value);
+
+  // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34;
+  inline bool has_identity_check_status() const;
+  inline void clear_identity_check_status();
+  static const int kIdentityCheckStatusFieldNumber = 34;
+  inline ::bgs::protocol::account::v1::IdentityVerificationStatus identity_check_status() const;
+  inline void set_identity_check_status(::bgs::protocol::account::v1::IdentityVerificationStatus value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountBlob)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_region();
+  inline void clear_has_region();
+  inline void set_has_flags();
+  inline void clear_has_flags();
+  inline void set_has_secure_release();
+  inline void clear_has_secure_release();
+  inline void set_has_whitelist_start();
+  inline void clear_has_whitelist_start();
+  inline void set_has_whitelist_end();
+  inline void clear_has_whitelist_end();
+  inline void set_has_full_name();
+  inline void clear_has_full_name();
+  inline void set_has_battle_tag();
+  inline void clear_has_battle_tag();
+  inline void set_has_default_currency();
+  inline void clear_has_default_currency();
+  inline void set_has_legal_region();
+  inline void clear_has_legal_region();
+  inline void set_has_legal_locale();
+  inline void clear_has_legal_locale();
+  inline void set_has_cache_expiration();
+  inline void clear_has_cache_expiration();
+  inline void set_has_parental_control_info();
+  inline void clear_has_parental_control_info();
+  inline void set_has_country();
+  inline void clear_has_country();
+  inline void set_has_preferred_region();
+  inline void clear_has_preferred_region();
+  inline void set_has_identity_check_status();
+  inline void clear_has_identity_check_status();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 id_;
+  ::google::protobuf::uint32 region_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> email_;
+  ::google::protobuf::uint64 flags_;
+  ::google::protobuf::uint64 secure_release_;
+  ::google::protobuf::uint64 whitelist_start_;
+  ::google::protobuf::uint64 whitelist_end_;
+  ::std::string* full_name_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense > licenses_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential > credentials_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink > account_links_;
+  ::std::string* battle_tag_;
+  ::google::protobuf::uint32 default_currency_;
+  ::google::protobuf::uint32 legal_region_;
+  ::google::protobuf::uint64 cache_expiration_;
+  ::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info_;
+  ::google::protobuf::uint32 legal_locale_;
+  ::google::protobuf::uint32 preferred_region_;
+  ::std::string* country_;
+  int identity_check_status_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static AccountBlob* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AccountBlobList : public ::google::protobuf::Message {
+ public:
+  AccountBlobList();
+  virtual ~AccountBlobList();
+
+  AccountBlobList(const AccountBlobList& from);
+
+  inline AccountBlobList& operator=(const AccountBlobList& 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 AccountBlobList& default_instance();
+
+  void Swap(AccountBlobList* other);
+
+  // implements Message ----------------------------------------------
+
+  AccountBlobList* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AccountBlobList& from);
+  void MergeFrom(const AccountBlobList& 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.AccountBlob blob = 1;
+  inline int blob_size() const;
+  inline void clear_blob();
+  static const int kBlobFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountBlob& blob(int index) const;
+  inline ::bgs::protocol::account::v1::AccountBlob* mutable_blob(int index);
+  inline ::bgs::protocol::account::v1::AccountBlob* add_blob();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountBlob >&
+      blob() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountBlob >*
+      mutable_blob();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountBlobList)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountBlob > blob_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static AccountBlobList* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameAccountHandle : public ::google::protobuf::Message {
+ public:
+  GameAccountHandle();
+  virtual ~GameAccountHandle();
+
+  GameAccountHandle(const GameAccountHandle& from);
+
+  inline GameAccountHandle& operator=(const GameAccountHandle& 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 GameAccountHandle& default_instance();
+
+  void Swap(GameAccountHandle* other);
+
+  // implements Message ----------------------------------------------
+
+  GameAccountHandle* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameAccountHandle& from);
+  void MergeFrom(const GameAccountHandle& 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 fixed32 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // required fixed32 program = 2;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 2;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // required uint32 region = 3;
+  inline bool has_region() const;
+  inline void clear_region();
+  static const int kRegionFieldNumber = 3;
+  inline ::google::protobuf::uint32 region() const;
+  inline void set_region(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountHandle)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_region();
+  inline void clear_has_region();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 id_;
+  ::google::protobuf::uint32 program_;
+  ::google::protobuf::uint32 region_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameAccountHandle* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameAccountLink : public ::google::protobuf::Message {
+ public:
+  GameAccountLink();
+  virtual ~GameAccountLink();
+
+  GameAccountLink(const GameAccountLink& from);
+
+  inline GameAccountLink& operator=(const GameAccountLink& 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 GameAccountLink& default_instance();
+
+  void Swap(GameAccountLink* other);
+
+  // implements Message ----------------------------------------------
+
+  GameAccountLink* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameAccountLink& from);
+  void MergeFrom(const GameAccountLink& 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.account.v1.GameAccountHandle game_account = 1;
+  inline bool has_game_account() const;
+  inline void clear_game_account();
+  static const int kGameAccountFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const;
+  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account();
+  inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account();
+  inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account);
+
+  // required string name = 2;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 2;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountLink)
+ private:
+  inline void set_has_game_account();
+  inline void clear_has_game_account();
+  inline void set_has_name();
+  inline void clear_has_name();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
+  ::std::string* name_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameAccountLink* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameAccountBlob : public ::google::protobuf::Message {
+ public:
+  GameAccountBlob();
+  virtual ~GameAccountBlob();
+
+  GameAccountBlob(const GameAccountBlob& from);
+
+  inline GameAccountBlob& operator=(const GameAccountBlob& 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 GameAccountBlob& default_instance();
+
+  void Swap(GameAccountBlob* other);
+
+  // implements Message ----------------------------------------------
+
+  GameAccountBlob* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameAccountBlob& from);
+  void MergeFrom(const GameAccountBlob& 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.account.v1.GameAccountHandle game_account = 1;
+  inline bool has_game_account() const;
+  inline void clear_game_account();
+  static const int kGameAccountFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const;
+  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account();
+  inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account();
+  inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account);
+
+  // optional string name = 2 [default = ""];
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 2;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional uint32 realm_permissions = 3 [default = 0];
+  inline bool has_realm_permissions() const;
+  inline void clear_realm_permissions();
+  static const int kRealmPermissionsFieldNumber = 3;
+  inline ::google::protobuf::uint32 realm_permissions() const;
+  inline void set_realm_permissions(::google::protobuf::uint32 value);
+
+  // required uint32 status = 4;
+  inline bool has_status() const;
+  inline void clear_status();
+  static const int kStatusFieldNumber = 4;
+  inline ::google::protobuf::uint32 status() const;
+  inline void set_status(::google::protobuf::uint32 value);
+
+  // optional uint64 flags = 5 [default = 0];
+  inline bool has_flags() const;
+  inline void clear_flags();
+  static const int kFlagsFieldNumber = 5;
+  inline ::google::protobuf::uint64 flags() const;
+  inline void set_flags(::google::protobuf::uint64 value);
+
+  // optional uint32 billing_flags = 6 [default = 0];
+  inline bool has_billing_flags() const;
+  inline void clear_billing_flags();
+  static const int kBillingFlagsFieldNumber = 6;
+  inline ::google::protobuf::uint32 billing_flags() const;
+  inline void set_billing_flags(::google::protobuf::uint32 value);
+
+  // required uint64 cache_expiration = 7;
+  inline bool has_cache_expiration() const;
+  inline void clear_cache_expiration();
+  static const int kCacheExpirationFieldNumber = 7;
+  inline ::google::protobuf::uint64 cache_expiration() const;
+  inline void set_cache_expiration(::google::protobuf::uint64 value);
+
+  // optional uint64 subscription_expiration = 10;
+  inline bool has_subscription_expiration() const;
+  inline void clear_subscription_expiration();
+  static const int kSubscriptionExpirationFieldNumber = 10;
+  inline ::google::protobuf::uint64 subscription_expiration() const;
+  inline void set_subscription_expiration(::google::protobuf::uint64 value);
+
+  // optional uint32 units_remaining = 11;
+  inline bool has_units_remaining() const;
+  inline void clear_units_remaining();
+  static const int kUnitsRemainingFieldNumber = 11;
+  inline ::google::protobuf::uint32 units_remaining() const;
+  inline void set_units_remaining(::google::protobuf::uint32 value);
+
+  // optional uint64 status_expiration = 12;
+  inline bool has_status_expiration() const;
+  inline void clear_status_expiration();
+  static const int kStatusExpirationFieldNumber = 12;
+  inline ::google::protobuf::uint64 status_expiration() const;
+  inline void set_status_expiration(::google::protobuf::uint64 value);
+
+  // optional uint32 box_level = 13;
+  inline bool has_box_level() const;
+  inline void clear_box_level();
+  static const int kBoxLevelFieldNumber = 13;
+  inline ::google::protobuf::uint32 box_level() const;
+  inline void set_box_level(::google::protobuf::uint32 value);
+
+  // optional uint64 box_level_expiration = 14;
+  inline bool has_box_level_expiration() const;
+  inline void clear_box_level_expiration();
+  static const int kBoxLevelExpirationFieldNumber = 14;
+  inline ::google::protobuf::uint64 box_level_expiration() const;
+  inline void set_box_level_expiration(::google::protobuf::uint64 value);
+
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
+  inline int licenses_size() const;
+  inline void clear_licenses();
+  static const int kLicensesFieldNumber = 20;
+  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 fixed32 raf_account = 21;
+  inline bool has_raf_account() const;
+  inline void clear_raf_account();
+  static const int kRafAccountFieldNumber = 21;
+  inline ::google::protobuf::uint32 raf_account() const;
+  inline void set_raf_account(::google::protobuf::uint32 value);
+
+  // optional bytes raf_info = 22;
+  inline bool has_raf_info() const;
+  inline void clear_raf_info();
+  static const int kRafInfoFieldNumber = 22;
+  inline const ::std::string& raf_info() const;
+  inline void set_raf_info(const ::std::string& value);
+  inline void set_raf_info(const char* value);
+  inline void set_raf_info(const void* value, size_t size);
+  inline ::std::string* mutable_raf_info();
+  inline ::std::string* release_raf_info();
+  inline void set_allocated_raf_info(::std::string* raf_info);
+
+  // optional uint64 raf_expiration = 23;
+  inline bool has_raf_expiration() const;
+  inline void clear_raf_expiration();
+  static const int kRafExpirationFieldNumber = 23;
+  inline ::google::protobuf::uint64 raf_expiration() const;
+  inline void set_raf_expiration(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountBlob)
+ private:
+  inline void set_has_game_account();
+  inline void clear_has_game_account();
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_realm_permissions();
+  inline void clear_has_realm_permissions();
+  inline void set_has_status();
+  inline void clear_has_status();
+  inline void set_has_flags();
+  inline void clear_has_flags();
+  inline void set_has_billing_flags();
+  inline void clear_has_billing_flags();
+  inline void set_has_cache_expiration();
+  inline void clear_has_cache_expiration();
+  inline void set_has_subscription_expiration();
+  inline void clear_has_subscription_expiration();
+  inline void set_has_units_remaining();
+  inline void clear_has_units_remaining();
+  inline void set_has_status_expiration();
+  inline void clear_has_status_expiration();
+  inline void set_has_box_level();
+  inline void clear_has_box_level();
+  inline void set_has_box_level_expiration();
+  inline void clear_has_box_level_expiration();
+  inline void set_has_raf_account();
+  inline void clear_has_raf_account();
+  inline void set_has_raf_info();
+  inline void clear_has_raf_info();
+  inline void set_has_raf_expiration();
+  inline void clear_has_raf_expiration();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
+  ::std::string* name_;
+  ::google::protobuf::uint32 realm_permissions_;
+  ::google::protobuf::uint32 status_;
+  ::google::protobuf::uint64 flags_;
+  ::google::protobuf::uint64 cache_expiration_;
+  ::google::protobuf::uint32 billing_flags_;
+  ::google::protobuf::uint32 units_remaining_;
+  ::google::protobuf::uint64 subscription_expiration_;
+  ::google::protobuf::uint64 status_expiration_;
+  ::google::protobuf::uint64 box_level_expiration_;
+  ::google::protobuf::uint32 box_level_;
+  ::google::protobuf::uint32 raf_account_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense > licenses_;
+  ::std::string* raf_info_;
+  ::google::protobuf::uint64 raf_expiration_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameAccountBlob* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameAccountBlobList : public ::google::protobuf::Message {
+ public:
+  GameAccountBlobList();
+  virtual ~GameAccountBlobList();
+
+  GameAccountBlobList(const GameAccountBlobList& from);
+
+  inline GameAccountBlobList& operator=(const GameAccountBlobList& 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 GameAccountBlobList& default_instance();
+
+  void Swap(GameAccountBlobList* other);
+
+  // implements Message ----------------------------------------------
+
+  GameAccountBlobList* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameAccountBlobList& from);
+  void MergeFrom(const GameAccountBlobList& 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.GameAccountBlob blob = 1;
+  inline int blob_size() const;
+  inline void clear_blob();
+  static const int kBlobFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::GameAccountBlob& blob(int index) const;
+  inline ::bgs::protocol::account::v1::GameAccountBlob* mutable_blob(int index);
+  inline ::bgs::protocol::account::v1::GameAccountBlob* add_blob();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountBlob >&
+      blob() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountBlob >*
+      mutable_blob();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountBlobList)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountBlob > blob_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameAccountBlobList* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AccountReference : public ::google::protobuf::Message {
+ public:
+  AccountReference();
+  virtual ~AccountReference();
+
+  AccountReference(const AccountReference& from);
+
+  inline AccountReference& operator=(const AccountReference& 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 AccountReference& default_instance();
+
+  void Swap(AccountReference* other);
+
+  // implements Message ----------------------------------------------
+
+  AccountReference* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AccountReference& from);
+  void MergeFrom(const AccountReference& 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 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // optional string email = 2;
+  inline bool has_email() const;
+  inline void clear_email();
+  static const int kEmailFieldNumber = 2;
+  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 .bgs.protocol.account.v1.GameAccountHandle handle = 3;
+  inline bool has_handle() const;
+  inline void clear_handle();
+  static const int kHandleFieldNumber = 3;
+  inline const ::bgs::protocol::account::v1::GameAccountHandle& handle() const;
+  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_handle();
+  inline ::bgs::protocol::account::v1::GameAccountHandle* release_handle();
+  inline void set_allocated_handle(::bgs::protocol::account::v1::GameAccountHandle* handle);
+
+  // optional string battle_tag = 4;
+  inline bool has_battle_tag() const;
+  inline void clear_battle_tag();
+  static const int kBattleTagFieldNumber = 4;
+  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 uint32 region = 10 [default = 0];
+  inline bool has_region() const;
+  inline void clear_region();
+  static const int kRegionFieldNumber = 10;
+  inline ::google::protobuf::uint32 region() const;
+  inline void set_region(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountReference)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_email();
+  inline void clear_has_email();
+  inline void set_has_handle();
+  inline void clear_has_handle();
+  inline void set_has_battle_tag();
+  inline void clear_has_battle_tag();
+  inline void set_has_region();
+  inline void clear_has_region();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* email_;
+  ::bgs::protocol::account::v1::GameAccountHandle* handle_;
+  ::google::protobuf::uint32 id_;
+  ::google::protobuf::uint32 region_;
+  ::std::string* battle_tag_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static AccountReference* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API Identity : public ::google::protobuf::Message {
+ public:
+  Identity();
+  virtual ~Identity();
+
+  Identity(const Identity& from);
+
+  inline Identity& operator=(const Identity& 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 Identity& default_instance();
+
+  void Swap(Identity* other);
+
+  // implements Message ----------------------------------------------
+
+  Identity* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Identity& from);
+  void MergeFrom(const Identity& 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.account.v1.AccountId account = 1;
+  inline bool has_account() const;
+  inline void clear_account();
+  static const int kAccountFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountId& account() const;
+  inline ::bgs::protocol::account::v1::AccountId* mutable_account();
+  inline ::bgs::protocol::account::v1::AccountId* release_account();
+  inline void set_allocated_account(::bgs::protocol::account::v1::AccountId* account);
+
+  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
+  inline bool has_game_account() const;
+  inline void clear_game_account();
+  static const int kGameAccountFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const;
+  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account();
+  inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account();
+  inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account);
+
+  // optional .bgs.protocol.ProcessId process = 3;
+  inline bool has_process() const;
+  inline void clear_process();
+  static const int kProcessFieldNumber = 3;
+  inline const ::bgs::protocol::ProcessId& process() const;
+  inline ::bgs::protocol::ProcessId* mutable_process();
+  inline ::bgs::protocol::ProcessId* release_process();
+  inline void set_allocated_process(::bgs::protocol::ProcessId* process);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.Identity)
+ private:
+  inline void set_has_account();
+  inline void clear_has_account();
+  inline void set_has_game_account();
+  inline void clear_has_game_account();
+  inline void set_has_process();
+  inline void clear_has_process();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountId* account_;
+  ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
+  ::bgs::protocol::ProcessId* process_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Identity* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ProgramTag : public ::google::protobuf::Message {
+ public:
+  ProgramTag();
+  virtual ~ProgramTag();
+
+  ProgramTag(const ProgramTag& from);
+
+  inline ProgramTag& operator=(const ProgramTag& 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 ProgramTag& default_instance();
+
+  void Swap(ProgramTag* other);
+
+  // implements Message ----------------------------------------------
+
+  ProgramTag* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ProgramTag& from);
+  void MergeFrom(const ProgramTag& 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);
+
+  // optional fixed32 tag = 2;
+  inline bool has_tag() const;
+  inline void clear_tag();
+  static const int kTagFieldNumber = 2;
+  inline ::google::protobuf::uint32 tag() const;
+  inline void set_tag(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.ProgramTag)
+ private:
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_tag();
+  inline void clear_has_tag();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 program_;
+  ::google::protobuf::uint32 tag_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ProgramTag* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API RegionTag : public ::google::protobuf::Message {
+ public:
+  RegionTag();
+  virtual ~RegionTag();
+
+  RegionTag(const RegionTag& from);
+
+  inline RegionTag& operator=(const RegionTag& 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 RegionTag& default_instance();
+
+  void Swap(RegionTag* other);
+
+  // implements Message ----------------------------------------------
+
+  RegionTag* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RegionTag& from);
+  void MergeFrom(const RegionTag& 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 region = 1;
+  inline bool has_region() const;
+  inline void clear_region();
+  static const int kRegionFieldNumber = 1;
+  inline ::google::protobuf::uint32 region() const;
+  inline void set_region(::google::protobuf::uint32 value);
+
+  // optional fixed32 tag = 2;
+  inline bool has_tag() const;
+  inline void clear_tag();
+  static const int kTagFieldNumber = 2;
+  inline ::google::protobuf::uint32 tag() const;
+  inline void set_tag(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.RegionTag)
+ private:
+  inline void set_has_region();
+  inline void clear_has_region();
+  inline void set_has_tag();
+  inline void clear_has_tag();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 region_;
+  ::google::protobuf::uint32 tag_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static RegionTag* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AccountFieldTags : public ::google::protobuf::Message {
+ public:
+  AccountFieldTags();
+  virtual ~AccountFieldTags();
+
+  AccountFieldTags(const AccountFieldTags& from);
+
+  inline AccountFieldTags& operator=(const AccountFieldTags& 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 AccountFieldTags& default_instance();
+
+  void Swap(AccountFieldTags* other);
+
+  // implements Message ----------------------------------------------
+
+  AccountFieldTags* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AccountFieldTags& from);
+  void MergeFrom(const AccountFieldTags& 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 account_level_info_tag = 2;
+  inline bool has_account_level_info_tag() const;
+  inline void clear_account_level_info_tag();
+  static const int kAccountLevelInfoTagFieldNumber = 2;
+  inline ::google::protobuf::uint32 account_level_info_tag() const;
+  inline void set_account_level_info_tag(::google::protobuf::uint32 value);
+
+  // optional fixed32 privacy_info_tag = 3;
+  inline bool has_privacy_info_tag() const;
+  inline void clear_privacy_info_tag();
+  static const int kPrivacyInfoTagFieldNumber = 3;
+  inline ::google::protobuf::uint32 privacy_info_tag() const;
+  inline void set_privacy_info_tag(::google::protobuf::uint32 value);
+
+  // optional fixed32 parental_control_info_tag = 4;
+  inline bool has_parental_control_info_tag() const;
+  inline void clear_parental_control_info_tag();
+  static const int kParentalControlInfoTagFieldNumber = 4;
+  inline ::google::protobuf::uint32 parental_control_info_tag() const;
+  inline void set_parental_control_info_tag(::google::protobuf::uint32 value);
+
+  // repeated .bgs.protocol.account.v1.ProgramTag game_level_info_tags = 7;
+  inline int game_level_info_tags_size() const;
+  inline void clear_game_level_info_tags();
+  static const int kGameLevelInfoTagsFieldNumber = 7;
+  inline const ::bgs::protocol::account::v1::ProgramTag& game_level_info_tags(int index) const;
+  inline ::bgs::protocol::account::v1::ProgramTag* mutable_game_level_info_tags(int index);
+  inline ::bgs::protocol::account::v1::ProgramTag* add_game_level_info_tags();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag >&
+      game_level_info_tags() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag >*
+      mutable_game_level_info_tags();
+
+  // repeated .bgs.protocol.account.v1.ProgramTag game_status_tags = 9;
+  inline int game_status_tags_size() const;
+  inline void clear_game_status_tags();
+  static const int kGameStatusTagsFieldNumber = 9;
+  inline const ::bgs::protocol::account::v1::ProgramTag& game_status_tags(int index) const;
+  inline ::bgs::protocol::account::v1::ProgramTag* mutable_game_status_tags(int index);
+  inline ::bgs::protocol::account::v1::ProgramTag* add_game_status_tags();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag >&
+      game_status_tags() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag >*
+      mutable_game_status_tags();
+
+  // repeated .bgs.protocol.account.v1.RegionTag game_account_tags = 11;
+  inline int game_account_tags_size() const;
+  inline void clear_game_account_tags();
+  static const int kGameAccountTagsFieldNumber = 11;
+  inline const ::bgs::protocol::account::v1::RegionTag& game_account_tags(int index) const;
+  inline ::bgs::protocol::account::v1::RegionTag* mutable_game_account_tags(int index);
+  inline ::bgs::protocol::account::v1::RegionTag* add_game_account_tags();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::RegionTag >&
+      game_account_tags() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::RegionTag >*
+      mutable_game_account_tags();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountFieldTags)
+ private:
+  inline void set_has_account_level_info_tag();
+  inline void clear_has_account_level_info_tag();
+  inline void set_has_privacy_info_tag();
+  inline void clear_has_privacy_info_tag();
+  inline void set_has_parental_control_info_tag();
+  inline void clear_has_parental_control_info_tag();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 account_level_info_tag_;
+  ::google::protobuf::uint32 privacy_info_tag_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag > game_level_info_tags_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag > game_status_tags_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::RegionTag > game_account_tags_;
+  ::google::protobuf::uint32 parental_control_info_tag_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static AccountFieldTags* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameAccountFieldTags : public ::google::protobuf::Message {
+ public:
+  GameAccountFieldTags();
+  virtual ~GameAccountFieldTags();
+
+  GameAccountFieldTags(const GameAccountFieldTags& from);
+
+  inline GameAccountFieldTags& operator=(const GameAccountFieldTags& 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 GameAccountFieldTags& default_instance();
+
+  void Swap(GameAccountFieldTags* other);
+
+  // implements Message ----------------------------------------------
+
+  GameAccountFieldTags* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameAccountFieldTags& from);
+  void MergeFrom(const GameAccountFieldTags& 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 game_level_info_tag = 2;
+  inline bool has_game_level_info_tag() const;
+  inline void clear_game_level_info_tag();
+  static const int kGameLevelInfoTagFieldNumber = 2;
+  inline ::google::protobuf::uint32 game_level_info_tag() const;
+  inline void set_game_level_info_tag(::google::protobuf::uint32 value);
+
+  // optional fixed32 game_time_info_tag = 3;
+  inline bool has_game_time_info_tag() const;
+  inline void clear_game_time_info_tag();
+  static const int kGameTimeInfoTagFieldNumber = 3;
+  inline ::google::protobuf::uint32 game_time_info_tag() const;
+  inline void set_game_time_info_tag(::google::protobuf::uint32 value);
+
+  // optional fixed32 game_status_tag = 4;
+  inline bool has_game_status_tag() const;
+  inline void clear_game_status_tag();
+  static const int kGameStatusTagFieldNumber = 4;
+  inline ::google::protobuf::uint32 game_status_tag() const;
+  inline void set_game_status_tag(::google::protobuf::uint32 value);
+
+  // optional fixed32 raf_info_tag = 5;
+  inline bool has_raf_info_tag() const;
+  inline void clear_raf_info_tag();
+  static const int kRafInfoTagFieldNumber = 5;
+  inline ::google::protobuf::uint32 raf_info_tag() const;
+  inline void set_raf_info_tag(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountFieldTags)
+ private:
+  inline void set_has_game_level_info_tag();
+  inline void clear_has_game_level_info_tag();
+  inline void set_has_game_time_info_tag();
+  inline void clear_has_game_time_info_tag();
+  inline void set_has_game_status_tag();
+  inline void clear_has_game_status_tag();
+  inline void set_has_raf_info_tag();
+  inline void clear_has_raf_info_tag();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 game_level_info_tag_;
+  ::google::protobuf::uint32 game_time_info_tag_;
+  ::google::protobuf::uint32 game_status_tag_;
+  ::google::protobuf::uint32 raf_info_tag_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameAccountFieldTags* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AccountFieldOptions : public ::google::protobuf::Message {
+ public:
+  AccountFieldOptions();
+  virtual ~AccountFieldOptions();
+
+  AccountFieldOptions(const AccountFieldOptions& from);
+
+  inline AccountFieldOptions& operator=(const AccountFieldOptions& 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 AccountFieldOptions& default_instance();
+
+  void Swap(AccountFieldOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  AccountFieldOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AccountFieldOptions& from);
+  void MergeFrom(const AccountFieldOptions& 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 bool all_fields = 1;
+  inline bool has_all_fields() const;
+  inline void clear_all_fields();
+  static const int kAllFieldsFieldNumber = 1;
+  inline bool all_fields() const;
+  inline void set_all_fields(bool value);
+
+  // optional bool field_account_level_info = 2;
+  inline bool has_field_account_level_info() const;
+  inline void clear_field_account_level_info();
+  static const int kFieldAccountLevelInfoFieldNumber = 2;
+  inline bool field_account_level_info() const;
+  inline void set_field_account_level_info(bool value);
+
+  // optional bool field_privacy_info = 3;
+  inline bool has_field_privacy_info() const;
+  inline void clear_field_privacy_info();
+  static const int kFieldPrivacyInfoFieldNumber = 3;
+  inline bool field_privacy_info() const;
+  inline void set_field_privacy_info(bool value);
+
+  // optional bool field_parental_control_info = 4;
+  inline bool has_field_parental_control_info() const;
+  inline void clear_field_parental_control_info();
+  static const int kFieldParentalControlInfoFieldNumber = 4;
+  inline bool field_parental_control_info() const;
+  inline void set_field_parental_control_info(bool value);
+
+  // optional bool field_game_level_info = 6;
+  inline bool has_field_game_level_info() const;
+  inline void clear_field_game_level_info();
+  static const int kFieldGameLevelInfoFieldNumber = 6;
+  inline bool field_game_level_info() const;
+  inline void set_field_game_level_info(bool value);
+
+  // optional bool field_game_status = 7;
+  inline bool has_field_game_status() const;
+  inline void clear_field_game_status();
+  static const int kFieldGameStatusFieldNumber = 7;
+  inline bool field_game_status() const;
+  inline void set_field_game_status(bool value);
+
+  // optional bool field_game_accounts = 8;
+  inline bool has_field_game_accounts() const;
+  inline void clear_field_game_accounts();
+  static const int kFieldGameAccountsFieldNumber = 8;
+  inline bool field_game_accounts() const;
+  inline void set_field_game_accounts(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountFieldOptions)
+ private:
+  inline void set_has_all_fields();
+  inline void clear_has_all_fields();
+  inline void set_has_field_account_level_info();
+  inline void clear_has_field_account_level_info();
+  inline void set_has_field_privacy_info();
+  inline void clear_has_field_privacy_info();
+  inline void set_has_field_parental_control_info();
+  inline void clear_has_field_parental_control_info();
+  inline void set_has_field_game_level_info();
+  inline void clear_has_field_game_level_info();
+  inline void set_has_field_game_status();
+  inline void clear_has_field_game_status();
+  inline void set_has_field_game_accounts();
+  inline void clear_has_field_game_accounts();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  bool all_fields_;
+  bool field_account_level_info_;
+  bool field_privacy_info_;
+  bool field_parental_control_info_;
+  bool field_game_level_info_;
+  bool field_game_status_;
+  bool field_game_accounts_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static AccountFieldOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameAccountFieldOptions : public ::google::protobuf::Message {
+ public:
+  GameAccountFieldOptions();
+  virtual ~GameAccountFieldOptions();
+
+  GameAccountFieldOptions(const GameAccountFieldOptions& from);
+
+  inline GameAccountFieldOptions& operator=(const GameAccountFieldOptions& 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 GameAccountFieldOptions& default_instance();
+
+  void Swap(GameAccountFieldOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  GameAccountFieldOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameAccountFieldOptions& from);
+  void MergeFrom(const GameAccountFieldOptions& 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 bool all_fields = 1;
+  inline bool has_all_fields() const;
+  inline void clear_all_fields();
+  static const int kAllFieldsFieldNumber = 1;
+  inline bool all_fields() const;
+  inline void set_all_fields(bool value);
+
+  // optional bool field_game_level_info = 2;
+  inline bool has_field_game_level_info() const;
+  inline void clear_field_game_level_info();
+  static const int kFieldGameLevelInfoFieldNumber = 2;
+  inline bool field_game_level_info() const;
+  inline void set_field_game_level_info(bool value);
+
+  // optional bool field_game_time_info = 3;
+  inline bool has_field_game_time_info() const;
+  inline void clear_field_game_time_info();
+  static const int kFieldGameTimeInfoFieldNumber = 3;
+  inline bool field_game_time_info() const;
+  inline void set_field_game_time_info(bool value);
+
+  // optional bool field_game_status = 4;
+  inline bool has_field_game_status() const;
+  inline void clear_field_game_status();
+  static const int kFieldGameStatusFieldNumber = 4;
+  inline bool field_game_status() const;
+  inline void set_field_game_status(bool value);
+
+  // optional bool field_raf_info = 5;
+  inline bool has_field_raf_info() const;
+  inline void clear_field_raf_info();
+  static const int kFieldRafInfoFieldNumber = 5;
+  inline bool field_raf_info() const;
+  inline void set_field_raf_info(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountFieldOptions)
+ private:
+  inline void set_has_all_fields();
+  inline void clear_has_all_fields();
+  inline void set_has_field_game_level_info();
+  inline void clear_has_field_game_level_info();
+  inline void set_has_field_game_time_info();
+  inline void clear_has_field_game_time_info();
+  inline void set_has_field_game_status();
+  inline void clear_has_field_game_status();
+  inline void set_has_field_raf_info();
+  inline void clear_has_field_raf_info();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  bool all_fields_;
+  bool field_game_level_info_;
+  bool field_game_time_info_;
+  bool field_game_status_;
+  bool field_raf_info_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameAccountFieldOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API SubscriberReference : public ::google::protobuf::Message {
+ public:
+  SubscriberReference();
+  virtual ~SubscriberReference();
+
+  SubscriberReference(const SubscriberReference& from);
+
+  inline SubscriberReference& operator=(const SubscriberReference& 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 SubscriberReference& default_instance();
+
+  void Swap(SubscriberReference* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscriberReference* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscriberReference& from);
+  void MergeFrom(const SubscriberReference& 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 uint64 object_id = 1 [default = 0];
+  inline bool has_object_id() const;
+  inline void clear_object_id();
+  static const int kObjectIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 object_id() const;
+  inline void set_object_id(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.EntityId entity_id = 2;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // optional .bgs.protocol.account.v1.AccountFieldOptions account_options = 3;
+  inline bool has_account_options() const;
+  inline void clear_account_options();
+  static const int kAccountOptionsFieldNumber = 3;
+  inline const ::bgs::protocol::account::v1::AccountFieldOptions& account_options() const;
+  inline ::bgs::protocol::account::v1::AccountFieldOptions* mutable_account_options();
+  inline ::bgs::protocol::account::v1::AccountFieldOptions* release_account_options();
+  inline void set_allocated_account_options(::bgs::protocol::account::v1::AccountFieldOptions* account_options);
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 4;
+  inline bool has_account_tags() const;
+  inline void clear_account_tags();
+  static const int kAccountTagsFieldNumber = 4;
+  inline const ::bgs::protocol::account::v1::AccountFieldTags& account_tags() const;
+  inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_account_tags();
+  inline ::bgs::protocol::account::v1::AccountFieldTags* release_account_tags();
+  inline void set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags);
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldOptions game_account_options = 5;
+  inline bool has_game_account_options() const;
+  inline void clear_game_account_options();
+  static const int kGameAccountOptionsFieldNumber = 5;
+  inline const ::bgs::protocol::account::v1::GameAccountFieldOptions& game_account_options() const;
+  inline ::bgs::protocol::account::v1::GameAccountFieldOptions* mutable_game_account_options();
+  inline ::bgs::protocol::account::v1::GameAccountFieldOptions* release_game_account_options();
+  inline void set_allocated_game_account_options(::bgs::protocol::account::v1::GameAccountFieldOptions* game_account_options);
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 6;
+  inline bool has_game_account_tags() const;
+  inline void clear_game_account_tags();
+  static const int kGameAccountTagsFieldNumber = 6;
+  inline const ::bgs::protocol::account::v1::GameAccountFieldTags& game_account_tags() const;
+  inline ::bgs::protocol::account::v1::GameAccountFieldTags* mutable_game_account_tags();
+  inline ::bgs::protocol::account::v1::GameAccountFieldTags* release_game_account_tags();
+  inline void set_allocated_game_account_tags(::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags);
+
+  // optional uint64 subscriber_id = 7 [default = 0];
+  inline bool has_subscriber_id() const;
+  inline void clear_subscriber_id();
+  static const int kSubscriberIdFieldNumber = 7;
+  inline ::google::protobuf::uint64 subscriber_id() const;
+  inline void set_subscriber_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.SubscriberReference)
+ private:
+  inline void set_has_object_id();
+  inline void clear_has_object_id();
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+  inline void set_has_account_options();
+  inline void clear_has_account_options();
+  inline void set_has_account_tags();
+  inline void clear_has_account_tags();
+  inline void set_has_game_account_options();
+  inline void clear_has_game_account_options();
+  inline void set_has_game_account_tags();
+  inline void clear_has_game_account_tags();
+  inline void set_has_subscriber_id();
+  inline void clear_has_subscriber_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 object_id_;
+  ::bgs::protocol::EntityId* entity_id_;
+  ::bgs::protocol::account::v1::AccountFieldOptions* account_options_;
+  ::bgs::protocol::account::v1::AccountFieldTags* account_tags_;
+  ::bgs::protocol::account::v1::GameAccountFieldOptions* game_account_options_;
+  ::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags_;
+  ::google::protobuf::uint64 subscriber_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscriberReference* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AccountLevelInfo : public ::google::protobuf::Message {
+ public:
+  AccountLevelInfo();
+  virtual ~AccountLevelInfo();
+
+  AccountLevelInfo(const AccountLevelInfo& from);
+
+  inline AccountLevelInfo& operator=(const AccountLevelInfo& 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 AccountLevelInfo& default_instance();
+
+  void Swap(AccountLevelInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  AccountLevelInfo* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AccountLevelInfo& from);
+  void MergeFrom(const AccountLevelInfo& 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 = 3;
+  inline int licenses_size() const;
+  inline void clear_licenses();
+  static const int kLicensesFieldNumber = 3;
+  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 fixed32 default_currency = 4;
+  inline bool has_default_currency() const;
+  inline void clear_default_currency();
+  static const int kDefaultCurrencyFieldNumber = 4;
+  inline ::google::protobuf::uint32 default_currency() const;
+  inline void set_default_currency(::google::protobuf::uint32 value);
+
+  // optional string country = 5;
+  inline bool has_country() const;
+  inline void clear_country();
+  static const int kCountryFieldNumber = 5;
+  inline const ::std::string& country() const;
+  inline void set_country(const ::std::string& value);
+  inline void set_country(const char* value);
+  inline void set_country(const char* value, size_t size);
+  inline ::std::string* mutable_country();
+  inline ::std::string* release_country();
+  inline void set_allocated_country(::std::string* country);
+
+  // optional uint32 preferred_region = 6;
+  inline bool has_preferred_region() const;
+  inline void clear_preferred_region();
+  static const int kPreferredRegionFieldNumber = 6;
+  inline ::google::protobuf::uint32 preferred_region() const;
+  inline void set_preferred_region(::google::protobuf::uint32 value);
+
+  // optional string full_name = 7;
+  inline bool has_full_name() const;
+  inline void clear_full_name();
+  static const int kFullNameFieldNumber = 7;
+  inline const ::std::string& full_name() const;
+  inline void set_full_name(const ::std::string& value);
+  inline void set_full_name(const char* value);
+  inline void set_full_name(const char* value, size_t size);
+  inline ::std::string* mutable_full_name();
+  inline ::std::string* release_full_name();
+  inline void set_allocated_full_name(::std::string* full_name);
+
+  // optional string battle_tag = 8;
+  inline bool has_battle_tag() const;
+  inline void clear_battle_tag();
+  static const int kBattleTagFieldNumber = 8;
+  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 bool muted = 9;
+  inline bool has_muted() const;
+  inline void clear_muted();
+  static const int kMutedFieldNumber = 9;
+  inline bool muted() const;
+  inline void set_muted(bool value);
+
+  // optional bool manual_review = 10;
+  inline bool has_manual_review() const;
+  inline void clear_manual_review();
+  static const int kManualReviewFieldNumber = 10;
+  inline bool manual_review() const;
+  inline void set_manual_review(bool value);
+
+  // optional bool account_paid_any = 11;
+  inline bool has_account_paid_any() const;
+  inline void clear_account_paid_any();
+  static const int kAccountPaidAnyFieldNumber = 11;
+  inline bool account_paid_any() const;
+  inline void set_account_paid_any(bool value);
+
+  // optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 12;
+  inline bool has_identity_check_status() const;
+  inline void clear_identity_check_status();
+  static const int kIdentityCheckStatusFieldNumber = 12;
+  inline ::bgs::protocol::account::v1::IdentityVerificationStatus identity_check_status() const;
+  inline void set_identity_check_status(::bgs::protocol::account::v1::IdentityVerificationStatus value);
+
+  // optional string email = 13;
+  inline bool has_email() const;
+  inline void clear_email();
+  static const int kEmailFieldNumber = 13;
+  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);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountLevelInfo)
+ private:
+  inline void set_has_default_currency();
+  inline void clear_has_default_currency();
+  inline void set_has_country();
+  inline void clear_has_country();
+  inline void set_has_preferred_region();
+  inline void clear_has_preferred_region();
+  inline void set_has_full_name();
+  inline void clear_has_full_name();
+  inline void set_has_battle_tag();
+  inline void clear_has_battle_tag();
+  inline void set_has_muted();
+  inline void clear_has_muted();
+  inline void set_has_manual_review();
+  inline void clear_has_manual_review();
+  inline void set_has_account_paid_any();
+  inline void clear_has_account_paid_any();
+  inline void set_has_identity_check_status();
+  inline void clear_has_identity_check_status();
+  inline void set_has_email();
+  inline void clear_has_email();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense > licenses_;
+  ::std::string* country_;
+  ::google::protobuf::uint32 default_currency_;
+  ::google::protobuf::uint32 preferred_region_;
+  ::std::string* full_name_;
+  ::std::string* battle_tag_;
+  bool muted_;
+  bool manual_review_;
+  bool account_paid_any_;
+  int identity_check_status_;
+  ::std::string* email_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static AccountLevelInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API PrivacyInfo : public ::google::protobuf::Message {
+ public:
+  PrivacyInfo();
+  virtual ~PrivacyInfo();
+
+  PrivacyInfo(const PrivacyInfo& from);
+
+  inline PrivacyInfo& operator=(const PrivacyInfo& 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 PrivacyInfo& default_instance();
+
+  void Swap(PrivacyInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  PrivacyInfo* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const PrivacyInfo& from);
+  void MergeFrom(const PrivacyInfo& 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 ----------------------------------------------------
+
+  typedef PrivacyInfo_GameInfoPrivacy GameInfoPrivacy;
+  static const GameInfoPrivacy PRIVACY_ME = PrivacyInfo_GameInfoPrivacy_PRIVACY_ME;
+  static const GameInfoPrivacy PRIVACY_FRIENDS = PrivacyInfo_GameInfoPrivacy_PRIVACY_FRIENDS;
+  static const GameInfoPrivacy PRIVACY_EVERYONE = PrivacyInfo_GameInfoPrivacy_PRIVACY_EVERYONE;
+  static inline bool GameInfoPrivacy_IsValid(int value) {
+    return PrivacyInfo_GameInfoPrivacy_IsValid(value);
+  }
+  static const GameInfoPrivacy GameInfoPrivacy_MIN =
+    PrivacyInfo_GameInfoPrivacy_GameInfoPrivacy_MIN;
+  static const GameInfoPrivacy GameInfoPrivacy_MAX =
+    PrivacyInfo_GameInfoPrivacy_GameInfoPrivacy_MAX;
+  static const int GameInfoPrivacy_ARRAYSIZE =
+    PrivacyInfo_GameInfoPrivacy_GameInfoPrivacy_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  GameInfoPrivacy_descriptor() {
+    return PrivacyInfo_GameInfoPrivacy_descriptor();
+  }
+  static inline const ::std::string& GameInfoPrivacy_Name(GameInfoPrivacy value) {
+    return PrivacyInfo_GameInfoPrivacy_Name(value);
+  }
+  static inline bool GameInfoPrivacy_Parse(const ::std::string& name,
+      GameInfoPrivacy* value) {
+    return PrivacyInfo_GameInfoPrivacy_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  // optional bool is_using_rid = 3;
+  inline bool has_is_using_rid() const;
+  inline void clear_is_using_rid();
+  static const int kIsUsingRidFieldNumber = 3;
+  inline bool is_using_rid() const;
+  inline void set_is_using_rid(bool value);
+
+  // optional bool is_real_id_visible_for_view_friends = 4;
+  inline bool has_is_real_id_visible_for_view_friends() const;
+  inline void clear_is_real_id_visible_for_view_friends();
+  static const int kIsRealIdVisibleForViewFriendsFieldNumber = 4;
+  inline bool is_real_id_visible_for_view_friends() const;
+  inline void set_is_real_id_visible_for_view_friends(bool value);
+
+  // optional bool is_hidden_from_friend_finder = 5;
+  inline bool has_is_hidden_from_friend_finder() const;
+  inline void clear_is_hidden_from_friend_finder();
+  static const int kIsHiddenFromFriendFinderFieldNumber = 5;
+  inline bool is_hidden_from_friend_finder() const;
+  inline void set_is_hidden_from_friend_finder(bool value);
+
+  // optional .bgs.protocol.account.v1.PrivacyInfo.GameInfoPrivacy game_info_privacy = 6 [default = PRIVACY_FRIENDS];
+  inline bool has_game_info_privacy() const;
+  inline void clear_game_info_privacy();
+  static const int kGameInfoPrivacyFieldNumber = 6;
+  inline ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy game_info_privacy() const;
+  inline void set_game_info_privacy(::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.PrivacyInfo)
+ private:
+  inline void set_has_is_using_rid();
+  inline void clear_has_is_using_rid();
+  inline void set_has_is_real_id_visible_for_view_friends();
+  inline void clear_has_is_real_id_visible_for_view_friends();
+  inline void set_has_is_hidden_from_friend_finder();
+  inline void clear_has_is_hidden_from_friend_finder();
+  inline void set_has_game_info_privacy();
+  inline void clear_has_game_info_privacy();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  bool is_using_rid_;
+  bool is_real_id_visible_for_view_friends_;
+  bool is_hidden_from_friend_finder_;
+  int game_info_privacy_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static PrivacyInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ParentalControlInfo : public ::google::protobuf::Message {
+ public:
+  ParentalControlInfo();
+  virtual ~ParentalControlInfo();
+
+  ParentalControlInfo(const ParentalControlInfo& from);
+
+  inline ParentalControlInfo& operator=(const ParentalControlInfo& 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 ParentalControlInfo& default_instance();
+
+  void Swap(ParentalControlInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  ParentalControlInfo* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ParentalControlInfo& from);
+  void MergeFrom(const ParentalControlInfo& 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 timezone = 3;
+  inline bool has_timezone() const;
+  inline void clear_timezone();
+  static const int kTimezoneFieldNumber = 3;
+  inline const ::std::string& timezone() const;
+  inline void set_timezone(const ::std::string& value);
+  inline void set_timezone(const char* value);
+  inline void set_timezone(const char* value, size_t size);
+  inline ::std::string* mutable_timezone();
+  inline ::std::string* release_timezone();
+  inline void set_allocated_timezone(::std::string* timezone);
+
+  // optional uint32 minutes_per_day = 4;
+  inline bool has_minutes_per_day() const;
+  inline void clear_minutes_per_day();
+  static const int kMinutesPerDayFieldNumber = 4;
+  inline ::google::protobuf::uint32 minutes_per_day() const;
+  inline void set_minutes_per_day(::google::protobuf::uint32 value);
+
+  // optional uint32 minutes_per_week = 5;
+  inline bool has_minutes_per_week() const;
+  inline void clear_minutes_per_week();
+  static const int kMinutesPerWeekFieldNumber = 5;
+  inline ::google::protobuf::uint32 minutes_per_week() const;
+  inline void set_minutes_per_week(::google::protobuf::uint32 value);
+
+  // optional bool can_receive_voice = 6;
+  inline bool has_can_receive_voice() const;
+  inline void clear_can_receive_voice();
+  static const int kCanReceiveVoiceFieldNumber = 6;
+  inline bool can_receive_voice() const;
+  inline void set_can_receive_voice(bool value);
+
+  // optional bool can_send_voice = 7;
+  inline bool has_can_send_voice() const;
+  inline void clear_can_send_voice();
+  static const int kCanSendVoiceFieldNumber = 7;
+  inline bool can_send_voice() const;
+  inline void set_can_send_voice(bool value);
+
+  // repeated bool play_schedule = 8;
+  inline int play_schedule_size() const;
+  inline void clear_play_schedule();
+  static const int kPlayScheduleFieldNumber = 8;
+  inline bool play_schedule(int index) const;
+  inline void set_play_schedule(int index, bool value);
+  inline void add_play_schedule(bool value);
+  inline const ::google::protobuf::RepeatedField< bool >&
+      play_schedule() const;
+  inline ::google::protobuf::RepeatedField< bool >*
+      mutable_play_schedule();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.ParentalControlInfo)
+ private:
+  inline void set_has_timezone();
+  inline void clear_has_timezone();
+  inline void set_has_minutes_per_day();
+  inline void clear_has_minutes_per_day();
+  inline void set_has_minutes_per_week();
+  inline void clear_has_minutes_per_week();
+  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_;
+  ::std::string* timezone_;
+  ::google::protobuf::uint32 minutes_per_day_;
+  ::google::protobuf::uint32 minutes_per_week_;
+  ::google::protobuf::RepeatedField< bool > play_schedule_;
+  bool can_receive_voice_;
+  bool can_send_voice_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ParentalControlInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameLevelInfo : public ::google::protobuf::Message {
+ public:
+  GameLevelInfo();
+  virtual ~GameLevelInfo();
+
+  GameLevelInfo(const GameLevelInfo& from);
+
+  inline GameLevelInfo& operator=(const GameLevelInfo& 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 GameLevelInfo& default_instance();
+
+  void Swap(GameLevelInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  GameLevelInfo* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameLevelInfo& from);
+  void MergeFrom(const GameLevelInfo& 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 bool is_trial = 4;
+  inline bool has_is_trial() const;
+  inline void clear_is_trial();
+  static const int kIsTrialFieldNumber = 4;
+  inline bool is_trial() const;
+  inline void set_is_trial(bool value);
+
+  // optional bool is_lifetime = 5;
+  inline bool has_is_lifetime() const;
+  inline void clear_is_lifetime();
+  static const int kIsLifetimeFieldNumber = 5;
+  inline bool is_lifetime() const;
+  inline void set_is_lifetime(bool value);
+
+  // optional bool is_restricted = 6;
+  inline bool has_is_restricted() const;
+  inline void clear_is_restricted();
+  static const int kIsRestrictedFieldNumber = 6;
+  inline bool is_restricted() const;
+  inline void set_is_restricted(bool value);
+
+  // optional bool is_beta = 7;
+  inline bool has_is_beta() const;
+  inline void clear_is_beta();
+  static const int kIsBetaFieldNumber = 7;
+  inline bool is_beta() const;
+  inline void set_is_beta(bool value);
+
+  // optional string name = 8;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 8;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional fixed32 program = 9;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 9;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 10;
+  inline int licenses_size() const;
+  inline void clear_licenses();
+  static const int kLicensesFieldNumber = 10;
+  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 uint32 realm_permissions = 11;
+  inline bool has_realm_permissions() const;
+  inline void clear_realm_permissions();
+  static const int kRealmPermissionsFieldNumber = 11;
+  inline ::google::protobuf::uint32 realm_permissions() const;
+  inline void set_realm_permissions(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameLevelInfo)
+ private:
+  inline void set_has_is_trial();
+  inline void clear_has_is_trial();
+  inline void set_has_is_lifetime();
+  inline void clear_has_is_lifetime();
+  inline void set_has_is_restricted();
+  inline void clear_has_is_restricted();
+  inline void set_has_is_beta();
+  inline void clear_has_is_beta();
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_realm_permissions();
+  inline void clear_has_realm_permissions();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  bool is_trial_;
+  bool is_lifetime_;
+  bool is_restricted_;
+  bool is_beta_;
+  ::google::protobuf::uint32 program_;
+  ::std::string* name_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense > licenses_;
+  ::google::protobuf::uint32 realm_permissions_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameLevelInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameTimeInfo : public ::google::protobuf::Message {
+ public:
+  GameTimeInfo();
+  virtual ~GameTimeInfo();
+
+  GameTimeInfo(const GameTimeInfo& from);
+
+  inline GameTimeInfo& operator=(const GameTimeInfo& 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 GameTimeInfo& default_instance();
+
+  void Swap(GameTimeInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  GameTimeInfo* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameTimeInfo& from);
+  void MergeFrom(const GameTimeInfo& 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 bool is_unlimited_play_time = 3;
+  inline bool has_is_unlimited_play_time() const;
+  inline void clear_is_unlimited_play_time();
+  static const int kIsUnlimitedPlayTimeFieldNumber = 3;
+  inline bool is_unlimited_play_time() const;
+  inline void set_is_unlimited_play_time(bool value);
+
+  // optional uint64 play_time_expires = 5;
+  inline bool has_play_time_expires() const;
+  inline void clear_play_time_expires();
+  static const int kPlayTimeExpiresFieldNumber = 5;
+  inline ::google::protobuf::uint64 play_time_expires() const;
+  inline void set_play_time_expires(::google::protobuf::uint64 value);
+
+  // optional bool is_subscription = 6;
+  inline bool has_is_subscription() const;
+  inline void clear_is_subscription();
+  static const int kIsSubscriptionFieldNumber = 6;
+  inline bool is_subscription() const;
+  inline void set_is_subscription(bool value);
+
+  // optional bool is_recurring_subscription = 7;
+  inline bool has_is_recurring_subscription() const;
+  inline void clear_is_recurring_subscription();
+  static const int kIsRecurringSubscriptionFieldNumber = 7;
+  inline bool is_recurring_subscription() const;
+  inline void set_is_recurring_subscription(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameTimeInfo)
+ private:
+  inline void set_has_is_unlimited_play_time();
+  inline void clear_has_is_unlimited_play_time();
+  inline void set_has_play_time_expires();
+  inline void clear_has_play_time_expires();
+  inline void set_has_is_subscription();
+  inline void clear_has_is_subscription();
+  inline void set_has_is_recurring_subscription();
+  inline void clear_has_is_recurring_subscription();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 play_time_expires_;
+  bool is_unlimited_play_time_;
+  bool is_subscription_;
+  bool is_recurring_subscription_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameTimeInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameTimeRemainingInfo : public ::google::protobuf::Message {
+ public:
+  GameTimeRemainingInfo();
+  virtual ~GameTimeRemainingInfo();
+
+  GameTimeRemainingInfo(const GameTimeRemainingInfo& from);
+
+  inline GameTimeRemainingInfo& operator=(const GameTimeRemainingInfo& 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 GameTimeRemainingInfo& default_instance();
+
+  void Swap(GameTimeRemainingInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  GameTimeRemainingInfo* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameTimeRemainingInfo& from);
+  void MergeFrom(const GameTimeRemainingInfo& 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 minutes_remaining = 1;
+  inline bool has_minutes_remaining() const;
+  inline void clear_minutes_remaining();
+  static const int kMinutesRemainingFieldNumber = 1;
+  inline ::google::protobuf::uint32 minutes_remaining() const;
+  inline void set_minutes_remaining(::google::protobuf::uint32 value);
+
+  // optional uint32 parental_daily_minutes_remaining = 2;
+  inline bool has_parental_daily_minutes_remaining() const;
+  inline void clear_parental_daily_minutes_remaining();
+  static const int kParentalDailyMinutesRemainingFieldNumber = 2;
+  inline ::google::protobuf::uint32 parental_daily_minutes_remaining() const;
+  inline void set_parental_daily_minutes_remaining(::google::protobuf::uint32 value);
+
+  // optional uint32 parental_weekly_minutes_remaining = 3;
+  inline bool has_parental_weekly_minutes_remaining() const;
+  inline void clear_parental_weekly_minutes_remaining();
+  static const int kParentalWeeklyMinutesRemainingFieldNumber = 3;
+  inline ::google::protobuf::uint32 parental_weekly_minutes_remaining() const;
+  inline void set_parental_weekly_minutes_remaining(::google::protobuf::uint32 value);
+
+  // optional uint32 seconds_remaining_until_kick = 4;
+  inline bool has_seconds_remaining_until_kick() const;
+  inline void clear_seconds_remaining_until_kick();
+  static const int kSecondsRemainingUntilKickFieldNumber = 4;
+  inline ::google::protobuf::uint32 seconds_remaining_until_kick() const;
+  inline void set_seconds_remaining_until_kick(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameTimeRemainingInfo)
+ private:
+  inline void set_has_minutes_remaining();
+  inline void clear_has_minutes_remaining();
+  inline void set_has_parental_daily_minutes_remaining();
+  inline void clear_has_parental_daily_minutes_remaining();
+  inline void set_has_parental_weekly_minutes_remaining();
+  inline void clear_has_parental_weekly_minutes_remaining();
+  inline void set_has_seconds_remaining_until_kick();
+  inline void clear_has_seconds_remaining_until_kick();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 minutes_remaining_;
+  ::google::protobuf::uint32 parental_daily_minutes_remaining_;
+  ::google::protobuf::uint32 parental_weekly_minutes_remaining_;
+  ::google::protobuf::uint32 seconds_remaining_until_kick_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameTimeRemainingInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameStatus : public ::google::protobuf::Message {
+ public:
+  GameStatus();
+  virtual ~GameStatus();
+
+  GameStatus(const GameStatus& from);
+
+  inline GameStatus& operator=(const GameStatus& 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 GameStatus& default_instance();
+
+  void Swap(GameStatus* other);
+
+  // implements Message ----------------------------------------------
+
+  GameStatus* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameStatus& from);
+  void MergeFrom(const GameStatus& 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 bool is_suspended = 4;
+  inline bool has_is_suspended() const;
+  inline void clear_is_suspended();
+  static const int kIsSuspendedFieldNumber = 4;
+  inline bool is_suspended() const;
+  inline void set_is_suspended(bool value);
+
+  // optional bool is_banned = 5;
+  inline bool has_is_banned() const;
+  inline void clear_is_banned();
+  static const int kIsBannedFieldNumber = 5;
+  inline bool is_banned() const;
+  inline void set_is_banned(bool value);
+
+  // optional uint64 suspension_expires = 6;
+  inline bool has_suspension_expires() const;
+  inline void clear_suspension_expires();
+  static const int kSuspensionExpiresFieldNumber = 6;
+  inline ::google::protobuf::uint64 suspension_expires() const;
+  inline void set_suspension_expires(::google::protobuf::uint64 value);
+
+  // optional fixed32 program = 7;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 7;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // optional bool is_locked = 8;
+  inline bool has_is_locked() const;
+  inline void clear_is_locked();
+  static const int kIsLockedFieldNumber = 8;
+  inline bool is_locked() const;
+  inline void set_is_locked(bool value);
+
+  // optional bool is_bam_unlockable = 9;
+  inline bool has_is_bam_unlockable() const;
+  inline void clear_is_bam_unlockable();
+  static const int kIsBamUnlockableFieldNumber = 9;
+  inline bool is_bam_unlockable() const;
+  inline void set_is_bam_unlockable(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameStatus)
+ private:
+  inline void set_has_is_suspended();
+  inline void clear_has_is_suspended();
+  inline void set_has_is_banned();
+  inline void clear_has_is_banned();
+  inline void set_has_suspension_expires();
+  inline void clear_has_suspension_expires();
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_is_locked();
+  inline void clear_has_is_locked();
+  inline void set_has_is_bam_unlockable();
+  inline void clear_has_is_bam_unlockable();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 suspension_expires_;
+  bool is_suspended_;
+  bool is_banned_;
+  bool is_locked_;
+  bool is_bam_unlockable_;
+  ::google::protobuf::uint32 program_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameStatus* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API RAFInfo : public ::google::protobuf::Message {
+ public:
+  RAFInfo();
+  virtual ~RAFInfo();
+
+  RAFInfo(const RAFInfo& from);
+
+  inline RAFInfo& operator=(const RAFInfo& 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 RAFInfo& default_instance();
+
+  void Swap(RAFInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  RAFInfo* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RAFInfo& from);
+  void MergeFrom(const RAFInfo& 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 raf_info = 1;
+  inline bool has_raf_info() const;
+  inline void clear_raf_info();
+  static const int kRafInfoFieldNumber = 1;
+  inline const ::std::string& raf_info() const;
+  inline void set_raf_info(const ::std::string& value);
+  inline void set_raf_info(const char* value);
+  inline void set_raf_info(const void* value, size_t size);
+  inline ::std::string* mutable_raf_info();
+  inline ::std::string* release_raf_info();
+  inline void set_allocated_raf_info(::std::string* raf_info);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.RAFInfo)
+ private:
+  inline void set_has_raf_info();
+  inline void clear_has_raf_info();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* raf_info_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static RAFInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameSessionInfo : public ::google::protobuf::Message {
+ public:
+  GameSessionInfo();
+  virtual ~GameSessionInfo();
+
+  GameSessionInfo(const GameSessionInfo& from);
+
+  inline GameSessionInfo& operator=(const GameSessionInfo& 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 GameSessionInfo& default_instance();
+
+  void Swap(GameSessionInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  GameSessionInfo* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameSessionInfo& from);
+  void MergeFrom(const GameSessionInfo& 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 start_time = 3 [deprecated = true];
+  inline bool has_start_time() const PROTOBUF_DEPRECATED;
+  inline void clear_start_time() PROTOBUF_DEPRECATED;
+  static const int kStartTimeFieldNumber = 3;
+  inline ::google::protobuf::uint32 start_time() const PROTOBUF_DEPRECATED;
+  inline void set_start_time(::google::protobuf::uint32 value) PROTOBUF_DEPRECATED;
+
+  // optional .bgs.protocol.account.v1.GameSessionLocation location = 4;
+  inline bool has_location() const;
+  inline void clear_location();
+  static const int kLocationFieldNumber = 4;
+  inline const ::bgs::protocol::account::v1::GameSessionLocation& location() const;
+  inline ::bgs::protocol::account::v1::GameSessionLocation* mutable_location();
+  inline ::bgs::protocol::account::v1::GameSessionLocation* release_location();
+  inline void set_allocated_location(::bgs::protocol::account::v1::GameSessionLocation* location);
+
+  // optional bool has_benefactor = 5;
+  inline bool has_has_benefactor() const;
+  inline void clear_has_benefactor();
+  static const int kHasBenefactorFieldNumber = 5;
+  inline bool has_benefactor() const;
+  inline void set_has_benefactor(bool value);
+
+  // optional bool is_using_igr = 6;
+  inline bool has_is_using_igr() const;
+  inline void clear_is_using_igr();
+  static const int kIsUsingIgrFieldNumber = 6;
+  inline bool is_using_igr() const;
+  inline void set_is_using_igr(bool value);
+
+  // optional bool parental_controls_active = 7;
+  inline bool has_parental_controls_active() const;
+  inline void clear_parental_controls_active();
+  static const int kParentalControlsActiveFieldNumber = 7;
+  inline bool parental_controls_active() const;
+  inline void set_parental_controls_active(bool value);
+
+  // optional uint64 start_time_sec = 8;
+  inline bool has_start_time_sec() const;
+  inline void clear_start_time_sec();
+  static const int kStartTimeSecFieldNumber = 8;
+  inline ::google::protobuf::uint64 start_time_sec() const;
+  inline void set_start_time_sec(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameSessionInfo)
+ private:
+  inline void set_has_start_time();
+  inline void clear_has_start_time();
+  inline void set_has_location();
+  inline void clear_has_location();
+  inline void set_has_has_benefactor();
+  inline void clear_has_has_benefactor();
+  inline void set_has_is_using_igr();
+  inline void clear_has_is_using_igr();
+  inline void set_has_parental_controls_active();
+  inline void clear_has_parental_controls_active();
+  inline void set_has_start_time_sec();
+  inline void clear_has_start_time_sec();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::GameSessionLocation* location_;
+  ::google::protobuf::uint32 start_time_;
+  bool has_benefactor_;
+  bool is_using_igr_;
+  bool parental_controls_active_;
+  ::google::protobuf::uint64 start_time_sec_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameSessionInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameSessionUpdateInfo : public ::google::protobuf::Message {
+ public:
+  GameSessionUpdateInfo();
+  virtual ~GameSessionUpdateInfo();
+
+  GameSessionUpdateInfo(const GameSessionUpdateInfo& from);
+
+  inline GameSessionUpdateInfo& operator=(const GameSessionUpdateInfo& 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 GameSessionUpdateInfo& default_instance();
+
+  void Swap(GameSessionUpdateInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  GameSessionUpdateInfo* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameSessionUpdateInfo& from);
+  void MergeFrom(const GameSessionUpdateInfo& 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.account.v1.CAIS cais = 8;
+  inline bool has_cais() const;
+  inline void clear_cais();
+  static const int kCaisFieldNumber = 8;
+  inline const ::bgs::protocol::account::v1::CAIS& cais() const;
+  inline ::bgs::protocol::account::v1::CAIS* mutable_cais();
+  inline ::bgs::protocol::account::v1::CAIS* release_cais();
+  inline void set_allocated_cais(::bgs::protocol::account::v1::CAIS* cais);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameSessionUpdateInfo)
+ private:
+  inline void set_has_cais();
+  inline void clear_has_cais();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::CAIS* cais_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameSessionUpdateInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameSessionLocation : public ::google::protobuf::Message {
+ public:
+  GameSessionLocation();
+  virtual ~GameSessionLocation();
+
+  GameSessionLocation(const GameSessionLocation& from);
+
+  inline GameSessionLocation& operator=(const GameSessionLocation& 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 GameSessionLocation& default_instance();
+
+  void Swap(GameSessionLocation* other);
+
+  // implements Message ----------------------------------------------
+
+  GameSessionLocation* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameSessionLocation& from);
+  void MergeFrom(const GameSessionLocation& 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 ip_address = 1;
+  inline bool has_ip_address() const;
+  inline void clear_ip_address();
+  static const int kIpAddressFieldNumber = 1;
+  inline const ::std::string& ip_address() const;
+  inline void set_ip_address(const ::std::string& value);
+  inline void set_ip_address(const char* value);
+  inline void set_ip_address(const char* value, size_t size);
+  inline ::std::string* mutable_ip_address();
+  inline ::std::string* release_ip_address();
+  inline void set_allocated_ip_address(::std::string* ip_address);
+
+  // optional uint32 country = 2;
+  inline bool has_country() const;
+  inline void clear_country();
+  static const int kCountryFieldNumber = 2;
+  inline ::google::protobuf::uint32 country() const;
+  inline void set_country(::google::protobuf::uint32 value);
+
+  // optional string city = 3;
+  inline bool has_city() const;
+  inline void clear_city();
+  static const int kCityFieldNumber = 3;
+  inline const ::std::string& city() const;
+  inline void set_city(const ::std::string& value);
+  inline void set_city(const char* value);
+  inline void set_city(const char* value, size_t size);
+  inline ::std::string* mutable_city();
+  inline ::std::string* release_city();
+  inline void set_allocated_city(::std::string* city);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameSessionLocation)
+ private:
+  inline void set_has_ip_address();
+  inline void clear_has_ip_address();
+  inline void set_has_country();
+  inline void clear_has_country();
+  inline void set_has_city();
+  inline void clear_has_city();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* ip_address_;
+  ::std::string* city_;
+  ::google::protobuf::uint32 country_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameSessionLocation* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API CAIS : public ::google::protobuf::Message {
+ public:
+  CAIS();
+  virtual ~CAIS();
+
+  CAIS(const CAIS& from);
+
+  inline CAIS& operator=(const CAIS& 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 CAIS& default_instance();
+
+  void Swap(CAIS* other);
+
+  // implements Message ----------------------------------------------
+
+  CAIS* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const CAIS& from);
+  void MergeFrom(const CAIS& 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 played_minutes = 1;
+  inline bool has_played_minutes() const;
+  inline void clear_played_minutes();
+  static const int kPlayedMinutesFieldNumber = 1;
+  inline ::google::protobuf::uint32 played_minutes() const;
+  inline void set_played_minutes(::google::protobuf::uint32 value);
+
+  // optional uint32 rested_minutes = 2;
+  inline bool has_rested_minutes() const;
+  inline void clear_rested_minutes();
+  static const int kRestedMinutesFieldNumber = 2;
+  inline ::google::protobuf::uint32 rested_minutes() const;
+  inline void set_rested_minutes(::google::protobuf::uint32 value);
+
+  // optional uint64 last_heard_time = 3;
+  inline bool has_last_heard_time() const;
+  inline void clear_last_heard_time();
+  static const int kLastHeardTimeFieldNumber = 3;
+  inline ::google::protobuf::uint64 last_heard_time() const;
+  inline void set_last_heard_time(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.CAIS)
+ private:
+  inline void set_has_played_minutes();
+  inline void clear_has_played_minutes();
+  inline void set_has_rested_minutes();
+  inline void clear_has_rested_minutes();
+  inline void set_has_last_heard_time();
+  inline void clear_has_last_heard_time();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 played_minutes_;
+  ::google::protobuf::uint32 rested_minutes_;
+  ::google::protobuf::uint64 last_heard_time_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static CAIS* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameAccountList : public ::google::protobuf::Message {
+ public:
+  GameAccountList();
+  virtual ~GameAccountList();
+
+  GameAccountList(const GameAccountList& from);
+
+  inline GameAccountList& operator=(const GameAccountList& 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 GameAccountList& default_instance();
+
+  void Swap(GameAccountList* other);
+
+  // implements Message ----------------------------------------------
+
+  GameAccountList* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameAccountList& from);
+  void MergeFrom(const GameAccountList& 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 region = 3;
+  inline bool has_region() const;
+  inline void clear_region();
+  static const int kRegionFieldNumber = 3;
+  inline ::google::protobuf::uint32 region() const;
+  inline void set_region(::google::protobuf::uint32 value);
+
+  // repeated .bgs.protocol.account.v1.GameAccountHandle handle = 4;
+  inline int handle_size() const;
+  inline void clear_handle();
+  static const int kHandleFieldNumber = 4;
+  inline const ::bgs::protocol::account::v1::GameAccountHandle& handle(int index) const;
+  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_handle(int index);
+  inline ::bgs::protocol::account::v1::GameAccountHandle* add_handle();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >&
+      handle() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >*
+      mutable_handle();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountList)
+ private:
+  inline void set_has_region();
+  inline void clear_has_region();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle > handle_;
+  ::google::protobuf::uint32 region_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameAccountList* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AccountState : public ::google::protobuf::Message {
+ public:
+  AccountState();
+  virtual ~AccountState();
+
+  AccountState(const AccountState& from);
+
+  inline AccountState& operator=(const AccountState& 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 AccountState& default_instance();
+
+  void Swap(AccountState* other);
+
+  // implements Message ----------------------------------------------
+
+  AccountState* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AccountState& from);
+  void MergeFrom(const AccountState& 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.account.v1.AccountLevelInfo account_level_info = 1;
+  inline bool has_account_level_info() const;
+  inline void clear_account_level_info();
+  static const int kAccountLevelInfoFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountLevelInfo& account_level_info() const;
+  inline ::bgs::protocol::account::v1::AccountLevelInfo* mutable_account_level_info();
+  inline ::bgs::protocol::account::v1::AccountLevelInfo* release_account_level_info();
+  inline void set_allocated_account_level_info(::bgs::protocol::account::v1::AccountLevelInfo* account_level_info);
+
+  // optional .bgs.protocol.account.v1.PrivacyInfo privacy_info = 2;
+  inline bool has_privacy_info() const;
+  inline void clear_privacy_info();
+  static const int kPrivacyInfoFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::PrivacyInfo& privacy_info() const;
+  inline ::bgs::protocol::account::v1::PrivacyInfo* mutable_privacy_info();
+  inline ::bgs::protocol::account::v1::PrivacyInfo* release_privacy_info();
+  inline void set_allocated_privacy_info(::bgs::protocol::account::v1::PrivacyInfo* privacy_info);
+
+  // optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 3;
+  inline bool has_parental_control_info() const;
+  inline void clear_parental_control_info();
+  static const int kParentalControlInfoFieldNumber = 3;
+  inline const ::bgs::protocol::account::v1::ParentalControlInfo& parental_control_info() const;
+  inline ::bgs::protocol::account::v1::ParentalControlInfo* mutable_parental_control_info();
+  inline ::bgs::protocol::account::v1::ParentalControlInfo* release_parental_control_info();
+  inline void set_allocated_parental_control_info(::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info);
+
+  // repeated .bgs.protocol.account.v1.GameLevelInfo game_level_info = 5;
+  inline int game_level_info_size() const;
+  inline void clear_game_level_info();
+  static const int kGameLevelInfoFieldNumber = 5;
+  inline const ::bgs::protocol::account::v1::GameLevelInfo& game_level_info(int index) const;
+  inline ::bgs::protocol::account::v1::GameLevelInfo* mutable_game_level_info(int index);
+  inline ::bgs::protocol::account::v1::GameLevelInfo* add_game_level_info();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameLevelInfo >&
+      game_level_info() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameLevelInfo >*
+      mutable_game_level_info();
+
+  // repeated .bgs.protocol.account.v1.GameStatus game_status = 6;
+  inline int game_status_size() const;
+  inline void clear_game_status();
+  static const int kGameStatusFieldNumber = 6;
+  inline const ::bgs::protocol::account::v1::GameStatus& game_status(int index) const;
+  inline ::bgs::protocol::account::v1::GameStatus* mutable_game_status(int index);
+  inline ::bgs::protocol::account::v1::GameStatus* add_game_status();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameStatus >&
+      game_status() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameStatus >*
+      mutable_game_status();
+
+  // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 7;
+  inline int game_accounts_size() const;
+  inline void clear_game_accounts();
+  static const int kGameAccountsFieldNumber = 7;
+  inline const ::bgs::protocol::account::v1::GameAccountList& game_accounts(int index) const;
+  inline ::bgs::protocol::account::v1::GameAccountList* mutable_game_accounts(int index);
+  inline ::bgs::protocol::account::v1::GameAccountList* add_game_accounts();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >&
+      game_accounts() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >*
+      mutable_game_accounts();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountState)
+ private:
+  inline void set_has_account_level_info();
+  inline void clear_has_account_level_info();
+  inline void set_has_privacy_info();
+  inline void clear_has_privacy_info();
+  inline void set_has_parental_control_info();
+  inline void clear_has_parental_control_info();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountLevelInfo* account_level_info_;
+  ::bgs::protocol::account::v1::PrivacyInfo* privacy_info_;
+  ::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameLevelInfo > game_level_info_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameStatus > game_status_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList > game_accounts_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static AccountState* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AccountStateTagged : public ::google::protobuf::Message {
+ public:
+  AccountStateTagged();
+  virtual ~AccountStateTagged();
+
+  AccountStateTagged(const AccountStateTagged& from);
+
+  inline AccountStateTagged& operator=(const AccountStateTagged& 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 AccountStateTagged& default_instance();
+
+  void Swap(AccountStateTagged* other);
+
+  // implements Message ----------------------------------------------
+
+  AccountStateTagged* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AccountStateTagged& from);
+  void MergeFrom(const AccountStateTagged& 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.account.v1.AccountState account_state = 1;
+  inline bool has_account_state() const;
+  inline void clear_account_state();
+  static const int kAccountStateFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::AccountState& account_state() const;
+  inline ::bgs::protocol::account::v1::AccountState* mutable_account_state();
+  inline ::bgs::protocol::account::v1::AccountState* release_account_state();
+  inline void set_allocated_account_state(::bgs::protocol::account::v1::AccountState* account_state);
+
+  // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 2;
+  inline bool has_account_tags() const;
+  inline void clear_account_tags();
+  static const int kAccountTagsFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::AccountFieldTags& account_tags() const;
+  inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_account_tags();
+  inline ::bgs::protocol::account::v1::AccountFieldTags* release_account_tags();
+  inline void set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountStateTagged)
+ private:
+  inline void set_has_account_state();
+  inline void clear_has_account_state();
+  inline void set_has_account_tags();
+  inline void clear_has_account_tags();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::AccountState* account_state_;
+  ::bgs::protocol::account::v1::AccountFieldTags* account_tags_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static AccountStateTagged* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameAccountState : public ::google::protobuf::Message {
+ public:
+  GameAccountState();
+  virtual ~GameAccountState();
+
+  GameAccountState(const GameAccountState& from);
+
+  inline GameAccountState& operator=(const GameAccountState& 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 GameAccountState& default_instance();
+
+  void Swap(GameAccountState* other);
+
+  // implements Message ----------------------------------------------
+
+  GameAccountState* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameAccountState& from);
+  void MergeFrom(const GameAccountState& 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.account.v1.GameLevelInfo game_level_info = 1;
+  inline bool has_game_level_info() const;
+  inline void clear_game_level_info();
+  static const int kGameLevelInfoFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::GameLevelInfo& game_level_info() const;
+  inline ::bgs::protocol::account::v1::GameLevelInfo* mutable_game_level_info();
+  inline ::bgs::protocol::account::v1::GameLevelInfo* release_game_level_info();
+  inline void set_allocated_game_level_info(::bgs::protocol::account::v1::GameLevelInfo* game_level_info);
+
+  // optional .bgs.protocol.account.v1.GameTimeInfo game_time_info = 2;
+  inline bool has_game_time_info() const;
+  inline void clear_game_time_info();
+  static const int kGameTimeInfoFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::GameTimeInfo& game_time_info() const;
+  inline ::bgs::protocol::account::v1::GameTimeInfo* mutable_game_time_info();
+  inline ::bgs::protocol::account::v1::GameTimeInfo* release_game_time_info();
+  inline void set_allocated_game_time_info(::bgs::protocol::account::v1::GameTimeInfo* game_time_info);
+
+  // optional .bgs.protocol.account.v1.GameStatus game_status = 3;
+  inline bool has_game_status() const;
+  inline void clear_game_status();
+  static const int kGameStatusFieldNumber = 3;
+  inline const ::bgs::protocol::account::v1::GameStatus& game_status() const;
+  inline ::bgs::protocol::account::v1::GameStatus* mutable_game_status();
+  inline ::bgs::protocol::account::v1::GameStatus* release_game_status();
+  inline void set_allocated_game_status(::bgs::protocol::account::v1::GameStatus* game_status);
+
+  // optional .bgs.protocol.account.v1.RAFInfo raf_info = 4;
+  inline bool has_raf_info() const;
+  inline void clear_raf_info();
+  static const int kRafInfoFieldNumber = 4;
+  inline const ::bgs::protocol::account::v1::RAFInfo& raf_info() const;
+  inline ::bgs::protocol::account::v1::RAFInfo* mutable_raf_info();
+  inline ::bgs::protocol::account::v1::RAFInfo* release_raf_info();
+  inline void set_allocated_raf_info(::bgs::protocol::account::v1::RAFInfo* raf_info);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountState)
+ private:
+  inline void set_has_game_level_info();
+  inline void clear_has_game_level_info();
+  inline void set_has_game_time_info();
+  inline void clear_has_game_time_info();
+  inline void set_has_game_status();
+  inline void clear_has_game_status();
+  inline void set_has_raf_info();
+  inline void clear_has_raf_info();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::GameLevelInfo* game_level_info_;
+  ::bgs::protocol::account::v1::GameTimeInfo* game_time_info_;
+  ::bgs::protocol::account::v1::GameStatus* game_status_;
+  ::bgs::protocol::account::v1::RAFInfo* raf_info_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameAccountState* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameAccountStateTagged : public ::google::protobuf::Message {
+ public:
+  GameAccountStateTagged();
+  virtual ~GameAccountStateTagged();
+
+  GameAccountStateTagged(const GameAccountStateTagged& from);
+
+  inline GameAccountStateTagged& operator=(const GameAccountStateTagged& 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 GameAccountStateTagged& default_instance();
+
+  void Swap(GameAccountStateTagged* other);
+
+  // implements Message ----------------------------------------------
+
+  GameAccountStateTagged* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameAccountStateTagged& from);
+  void MergeFrom(const GameAccountStateTagged& 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.account.v1.GameAccountState game_account_state = 1;
+  inline bool has_game_account_state() const;
+  inline void clear_game_account_state();
+  static const int kGameAccountStateFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::GameAccountState& game_account_state() const;
+  inline ::bgs::protocol::account::v1::GameAccountState* mutable_game_account_state();
+  inline ::bgs::protocol::account::v1::GameAccountState* release_game_account_state();
+  inline void set_allocated_game_account_state(::bgs::protocol::account::v1::GameAccountState* game_account_state);
+
+  // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 2;
+  inline bool has_game_account_tags() const;
+  inline void clear_game_account_tags();
+  static const int kGameAccountTagsFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::GameAccountFieldTags& game_account_tags() const;
+  inline ::bgs::protocol::account::v1::GameAccountFieldTags* mutable_game_account_tags();
+  inline ::bgs::protocol::account::v1::GameAccountFieldTags* release_game_account_tags();
+  inline void set_allocated_game_account_tags(::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountStateTagged)
+ private:
+  inline void set_has_game_account_state();
+  inline void clear_has_game_account_state();
+  inline void set_has_game_account_tags();
+  inline void clear_has_game_account_tags();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::GameAccountState* game_account_state_;
+  ::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameAccountStateTagged* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AuthorizedData : public ::google::protobuf::Message {
+ public:
+  AuthorizedData();
+  virtual ~AuthorizedData();
+
+  AuthorizedData(const AuthorizedData& from);
+
+  inline AuthorizedData& operator=(const AuthorizedData& 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 AuthorizedData& default_instance();
+
+  void Swap(AuthorizedData* other);
+
+  // implements Message ----------------------------------------------
+
+  AuthorizedData* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AuthorizedData& from);
+  void MergeFrom(const AuthorizedData& 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 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 char* value, size_t size);
+  inline ::std::string* mutable_data();
+  inline ::std::string* release_data();
+  inline void set_allocated_data(::std::string* data);
+
+  // repeated uint32 license = 2;
+  inline int license_size() const;
+  inline void clear_license();
+  static const int kLicenseFieldNumber = 2;
+  inline ::google::protobuf::uint32 license(int index) const;
+  inline void set_license(int index, ::google::protobuf::uint32 value);
+  inline void add_license(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      license() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_license();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AuthorizedData)
+ 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_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > license_;
+  friend void TC_SHARED_API protobuf_AddDesc_account_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_account_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static AuthorizedData* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// AccountId
+
+// required fixed32 id = 1;
+inline bool AccountId::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AccountId::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AccountId::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AccountId::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 AccountId::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountId.id)
+  return id_;
+}
+inline void AccountId::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountId.id)
+}
+
+// -------------------------------------------------------------------
+
+// AccountLicense
+
+// required uint32 id = 1;
+inline bool AccountLicense::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AccountLicense::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AccountLicense::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AccountLicense::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 AccountLicense::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLicense.id)
+  return id_;
+}
+inline void AccountLicense::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLicense.id)
+}
+
+// optional uint64 expires = 2;
+inline bool AccountLicense::has_expires() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AccountLicense::set_has_expires() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AccountLicense::clear_has_expires() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AccountLicense::clear_expires() {
+  expires_ = GOOGLE_ULONGLONG(0);
+  clear_has_expires();
+}
+inline ::google::protobuf::uint64 AccountLicense::expires() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLicense.expires)
+  return expires_;
+}
+inline void AccountLicense::set_expires(::google::protobuf::uint64 value) {
+  set_has_expires();
+  expires_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLicense.expires)
+}
+
+// -------------------------------------------------------------------
+
+// AccountCredential
+
+// required uint32 id = 1;
+inline bool AccountCredential::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AccountCredential::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AccountCredential::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AccountCredential::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 AccountCredential::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountCredential.id)
+  return id_;
+}
+inline void AccountCredential::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountCredential.id)
+}
+
+// optional bytes data = 2;
+inline bool AccountCredential::has_data() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AccountCredential::set_has_data() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AccountCredential::clear_has_data() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AccountCredential::clear_data() {
+  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    data_->clear();
+  }
+  clear_has_data();
+}
+inline const ::std::string& AccountCredential::data() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountCredential.data)
+  return *data_;
+}
+inline void AccountCredential::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.account.v1.AccountCredential.data)
+}
+inline void AccountCredential::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.account.v1.AccountCredential.data)
+}
+inline void AccountCredential::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.account.v1.AccountCredential.data)
+}
+inline ::std::string* AccountCredential::mutable_data() {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    data_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountCredential.data)
+  return data_;
+}
+inline ::std::string* AccountCredential::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 AccountCredential::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.account.v1.AccountCredential.data)
+}
+
+// -------------------------------------------------------------------
+
+// AccountBlob
+
+// required fixed32 id = 2;
+inline bool AccountBlob::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AccountBlob::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AccountBlob::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AccountBlob::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 AccountBlob::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.id)
+  return id_;
+}
+inline void AccountBlob::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.id)
+}
+
+// required uint32 region = 3;
+inline bool AccountBlob::has_region() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AccountBlob::set_has_region() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AccountBlob::clear_has_region() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AccountBlob::clear_region() {
+  region_ = 0u;
+  clear_has_region();
+}
+inline ::google::protobuf::uint32 AccountBlob::region() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.region)
+  return region_;
+}
+inline void AccountBlob::set_region(::google::protobuf::uint32 value) {
+  set_has_region();
+  region_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.region)
+}
+
+// repeated string email = 4;
+inline int AccountBlob::email_size() const {
+  return email_.size();
+}
+inline void AccountBlob::clear_email() {
+  email_.Clear();
+}
+inline const ::std::string& AccountBlob::email(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.email)
+  return email_.Get(index);
+}
+inline ::std::string* AccountBlob::mutable_email(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.email)
+  return email_.Mutable(index);
+}
+inline void AccountBlob::set_email(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.email)
+  email_.Mutable(index)->assign(value);
+}
+inline void AccountBlob::set_email(int index, const char* value) {
+  email_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountBlob.email)
+}
+inline void AccountBlob::set_email(int index, const char* value, size_t size) {
+  email_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountBlob.email)
+}
+inline ::std::string* AccountBlob::add_email() {
+  return email_.Add();
+}
+inline void AccountBlob::add_email(const ::std::string& value) {
+  email_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountBlob.email)
+}
+inline void AccountBlob::add_email(const char* value) {
+  email_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:bgs.protocol.account.v1.AccountBlob.email)
+}
+inline void AccountBlob::add_email(const char* value, size_t size) {
+  email_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:bgs.protocol.account.v1.AccountBlob.email)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+AccountBlob::email() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountBlob.email)
+  return email_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+AccountBlob::mutable_email() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountBlob.email)
+  return &email_;
+}
+
+// required uint64 flags = 5;
+inline bool AccountBlob::has_flags() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void AccountBlob::set_has_flags() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void AccountBlob::clear_has_flags() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void AccountBlob::clear_flags() {
+  flags_ = GOOGLE_ULONGLONG(0);
+  clear_has_flags();
+}
+inline ::google::protobuf::uint64 AccountBlob::flags() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.flags)
+  return flags_;
+}
+inline void AccountBlob::set_flags(::google::protobuf::uint64 value) {
+  set_has_flags();
+  flags_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.flags)
+}
+
+// optional uint64 secure_release = 6;
+inline bool AccountBlob::has_secure_release() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void AccountBlob::set_has_secure_release() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void AccountBlob::clear_has_secure_release() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void AccountBlob::clear_secure_release() {
+  secure_release_ = GOOGLE_ULONGLONG(0);
+  clear_has_secure_release();
+}
+inline ::google::protobuf::uint64 AccountBlob::secure_release() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.secure_release)
+  return secure_release_;
+}
+inline void AccountBlob::set_secure_release(::google::protobuf::uint64 value) {
+  set_has_secure_release();
+  secure_release_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.secure_release)
+}
+
+// optional uint64 whitelist_start = 7;
+inline bool AccountBlob::has_whitelist_start() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void AccountBlob::set_has_whitelist_start() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void AccountBlob::clear_has_whitelist_start() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void AccountBlob::clear_whitelist_start() {
+  whitelist_start_ = GOOGLE_ULONGLONG(0);
+  clear_has_whitelist_start();
+}
+inline ::google::protobuf::uint64 AccountBlob::whitelist_start() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.whitelist_start)
+  return whitelist_start_;
+}
+inline void AccountBlob::set_whitelist_start(::google::protobuf::uint64 value) {
+  set_has_whitelist_start();
+  whitelist_start_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.whitelist_start)
+}
+
+// optional uint64 whitelist_end = 8;
+inline bool AccountBlob::has_whitelist_end() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void AccountBlob::set_has_whitelist_end() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void AccountBlob::clear_has_whitelist_end() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void AccountBlob::clear_whitelist_end() {
+  whitelist_end_ = GOOGLE_ULONGLONG(0);
+  clear_has_whitelist_end();
+}
+inline ::google::protobuf::uint64 AccountBlob::whitelist_end() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.whitelist_end)
+  return whitelist_end_;
+}
+inline void AccountBlob::set_whitelist_end(::google::protobuf::uint64 value) {
+  set_has_whitelist_end();
+  whitelist_end_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.whitelist_end)
+}
+
+// required string full_name = 10;
+inline bool AccountBlob::has_full_name() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void AccountBlob::set_has_full_name() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void AccountBlob::clear_has_full_name() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void AccountBlob::clear_full_name() {
+  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_->clear();
+  }
+  clear_has_full_name();
+}
+inline const ::std::string& AccountBlob::full_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.full_name)
+  return *full_name_;
+}
+inline void AccountBlob::set_full_name(const ::std::string& value) {
+  set_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_ = new ::std::string;
+  }
+  full_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.full_name)
+}
+inline void AccountBlob::set_full_name(const char* value) {
+  set_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_ = new ::std::string;
+  }
+  full_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountBlob.full_name)
+}
+inline void AccountBlob::set_full_name(const char* value, size_t size) {
+  set_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_ = new ::std::string;
+  }
+  full_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountBlob.full_name)
+}
+inline ::std::string* AccountBlob::mutable_full_name() {
+  set_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.full_name)
+  return full_name_;
+}
+inline ::std::string* AccountBlob::release_full_name() {
+  clear_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = full_name_;
+    full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void AccountBlob::set_allocated_full_name(::std::string* full_name) {
+  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete full_name_;
+  }
+  if (full_name) {
+    set_has_full_name();
+    full_name_ = full_name;
+  } else {
+    clear_has_full_name();
+    full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountBlob.full_name)
+}
+
+// repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
+inline int AccountBlob::licenses_size() const {
+  return licenses_.size();
+}
+inline void AccountBlob::clear_licenses() {
+  licenses_.Clear();
+}
+inline const ::bgs::protocol::account::v1::AccountLicense& AccountBlob::licenses(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.licenses)
+  return licenses_.Get(index);
+}
+inline ::bgs::protocol::account::v1::AccountLicense* AccountBlob::mutable_licenses(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.licenses)
+  return licenses_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::AccountLicense* AccountBlob::add_licenses() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountBlob.licenses)
+  return licenses_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >&
+AccountBlob::licenses() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountBlob.licenses)
+  return licenses_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >*
+AccountBlob::mutable_licenses() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountBlob.licenses)
+  return &licenses_;
+}
+
+// repeated .bgs.protocol.account.v1.AccountCredential credentials = 21;
+inline int AccountBlob::credentials_size() const {
+  return credentials_.size();
+}
+inline void AccountBlob::clear_credentials() {
+  credentials_.Clear();
+}
+inline const ::bgs::protocol::account::v1::AccountCredential& AccountBlob::credentials(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.credentials)
+  return credentials_.Get(index);
+}
+inline ::bgs::protocol::account::v1::AccountCredential* AccountBlob::mutable_credentials(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.credentials)
+  return credentials_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::AccountCredential* AccountBlob::add_credentials() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountBlob.credentials)
+  return credentials_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >&
+AccountBlob::credentials() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountBlob.credentials)
+  return credentials_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountCredential >*
+AccountBlob::mutable_credentials() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountBlob.credentials)
+  return &credentials_;
+}
+
+// repeated .bgs.protocol.account.v1.GameAccountLink account_links = 22;
+inline int AccountBlob::account_links_size() const {
+  return account_links_.size();
+}
+inline void AccountBlob::clear_account_links() {
+  account_links_.Clear();
+}
+inline const ::bgs::protocol::account::v1::GameAccountLink& AccountBlob::account_links(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.account_links)
+  return account_links_.Get(index);
+}
+inline ::bgs::protocol::account::v1::GameAccountLink* AccountBlob::mutable_account_links(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.account_links)
+  return account_links_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::GameAccountLink* AccountBlob::add_account_links() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountBlob.account_links)
+  return account_links_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >&
+AccountBlob::account_links() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountBlob.account_links)
+  return account_links_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountLink >*
+AccountBlob::mutable_account_links() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountBlob.account_links)
+  return &account_links_;
+}
+
+// optional string battle_tag = 23;
+inline bool AccountBlob::has_battle_tag() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void AccountBlob::set_has_battle_tag() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void AccountBlob::clear_has_battle_tag() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void AccountBlob::clear_battle_tag() {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_->clear();
+  }
+  clear_has_battle_tag();
+}
+inline const ::std::string& AccountBlob::battle_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.battle_tag)
+  return *battle_tag_;
+}
+inline void AccountBlob::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.account.v1.AccountBlob.battle_tag)
+}
+inline void AccountBlob::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.account.v1.AccountBlob.battle_tag)
+}
+inline void AccountBlob::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.account.v1.AccountBlob.battle_tag)
+}
+inline ::std::string* AccountBlob::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.account.v1.AccountBlob.battle_tag)
+  return battle_tag_;
+}
+inline ::std::string* AccountBlob::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 AccountBlob::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.account.v1.AccountBlob.battle_tag)
+}
+
+// optional fixed32 default_currency = 25;
+inline bool AccountBlob::has_default_currency() const {
+  return (_has_bits_[0] & 0x00001000u) != 0;
+}
+inline void AccountBlob::set_has_default_currency() {
+  _has_bits_[0] |= 0x00001000u;
+}
+inline void AccountBlob::clear_has_default_currency() {
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline void AccountBlob::clear_default_currency() {
+  default_currency_ = 0u;
+  clear_has_default_currency();
+}
+inline ::google::protobuf::uint32 AccountBlob::default_currency() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.default_currency)
+  return default_currency_;
+}
+inline void AccountBlob::set_default_currency(::google::protobuf::uint32 value) {
+  set_has_default_currency();
+  default_currency_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.default_currency)
+}
+
+// optional uint32 legal_region = 26;
+inline bool AccountBlob::has_legal_region() const {
+  return (_has_bits_[0] & 0x00002000u) != 0;
+}
+inline void AccountBlob::set_has_legal_region() {
+  _has_bits_[0] |= 0x00002000u;
+}
+inline void AccountBlob::clear_has_legal_region() {
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline void AccountBlob::clear_legal_region() {
+  legal_region_ = 0u;
+  clear_has_legal_region();
+}
+inline ::google::protobuf::uint32 AccountBlob::legal_region() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.legal_region)
+  return legal_region_;
+}
+inline void AccountBlob::set_legal_region(::google::protobuf::uint32 value) {
+  set_has_legal_region();
+  legal_region_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.legal_region)
+}
+
+// optional fixed32 legal_locale = 27;
+inline bool AccountBlob::has_legal_locale() const {
+  return (_has_bits_[0] & 0x00004000u) != 0;
+}
+inline void AccountBlob::set_has_legal_locale() {
+  _has_bits_[0] |= 0x00004000u;
+}
+inline void AccountBlob::clear_has_legal_locale() {
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline void AccountBlob::clear_legal_locale() {
+  legal_locale_ = 0u;
+  clear_has_legal_locale();
+}
+inline ::google::protobuf::uint32 AccountBlob::legal_locale() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.legal_locale)
+  return legal_locale_;
+}
+inline void AccountBlob::set_legal_locale(::google::protobuf::uint32 value) {
+  set_has_legal_locale();
+  legal_locale_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.legal_locale)
+}
+
+// required uint64 cache_expiration = 30;
+inline bool AccountBlob::has_cache_expiration() const {
+  return (_has_bits_[0] & 0x00008000u) != 0;
+}
+inline void AccountBlob::set_has_cache_expiration() {
+  _has_bits_[0] |= 0x00008000u;
+}
+inline void AccountBlob::clear_has_cache_expiration() {
+  _has_bits_[0] &= ~0x00008000u;
+}
+inline void AccountBlob::clear_cache_expiration() {
+  cache_expiration_ = GOOGLE_ULONGLONG(0);
+  clear_has_cache_expiration();
+}
+inline ::google::protobuf::uint64 AccountBlob::cache_expiration() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.cache_expiration)
+  return cache_expiration_;
+}
+inline void AccountBlob::set_cache_expiration(::google::protobuf::uint64 value) {
+  set_has_cache_expiration();
+  cache_expiration_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.cache_expiration)
+}
+
+// optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 31;
+inline bool AccountBlob::has_parental_control_info() const {
+  return (_has_bits_[0] & 0x00010000u) != 0;
+}
+inline void AccountBlob::set_has_parental_control_info() {
+  _has_bits_[0] |= 0x00010000u;
+}
+inline void AccountBlob::clear_has_parental_control_info() {
+  _has_bits_[0] &= ~0x00010000u;
+}
+inline void AccountBlob::clear_parental_control_info() {
+  if (parental_control_info_ != NULL) parental_control_info_->::bgs::protocol::account::v1::ParentalControlInfo::Clear();
+  clear_has_parental_control_info();
+}
+inline const ::bgs::protocol::account::v1::ParentalControlInfo& AccountBlob::parental_control_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.parental_control_info)
+  return parental_control_info_ != NULL ? *parental_control_info_ : *default_instance_->parental_control_info_;
+}
+inline ::bgs::protocol::account::v1::ParentalControlInfo* AccountBlob::mutable_parental_control_info() {
+  set_has_parental_control_info();
+  if (parental_control_info_ == NULL) parental_control_info_ = new ::bgs::protocol::account::v1::ParentalControlInfo;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.parental_control_info)
+  return parental_control_info_;
+}
+inline ::bgs::protocol::account::v1::ParentalControlInfo* AccountBlob::release_parental_control_info() {
+  clear_has_parental_control_info();
+  ::bgs::protocol::account::v1::ParentalControlInfo* temp = parental_control_info_;
+  parental_control_info_ = NULL;
+  return temp;
+}
+inline void AccountBlob::set_allocated_parental_control_info(::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info) {
+  delete parental_control_info_;
+  parental_control_info_ = parental_control_info;
+  if (parental_control_info) {
+    set_has_parental_control_info();
+  } else {
+    clear_has_parental_control_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountBlob.parental_control_info)
+}
+
+// optional string country = 32;
+inline bool AccountBlob::has_country() const {
+  return (_has_bits_[0] & 0x00020000u) != 0;
+}
+inline void AccountBlob::set_has_country() {
+  _has_bits_[0] |= 0x00020000u;
+}
+inline void AccountBlob::clear_has_country() {
+  _has_bits_[0] &= ~0x00020000u;
+}
+inline void AccountBlob::clear_country() {
+  if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    country_->clear();
+  }
+  clear_has_country();
+}
+inline const ::std::string& AccountBlob::country() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.country)
+  return *country_;
+}
+inline void AccountBlob::set_country(const ::std::string& value) {
+  set_has_country();
+  if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    country_ = new ::std::string;
+  }
+  country_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.country)
+}
+inline void AccountBlob::set_country(const char* value) {
+  set_has_country();
+  if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    country_ = new ::std::string;
+  }
+  country_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountBlob.country)
+}
+inline void AccountBlob::set_country(const char* value, size_t size) {
+  set_has_country();
+  if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    country_ = new ::std::string;
+  }
+  country_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountBlob.country)
+}
+inline ::std::string* AccountBlob::mutable_country() {
+  set_has_country();
+  if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    country_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlob.country)
+  return country_;
+}
+inline ::std::string* AccountBlob::release_country() {
+  clear_has_country();
+  if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = country_;
+    country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void AccountBlob::set_allocated_country(::std::string* country) {
+  if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete country_;
+  }
+  if (country) {
+    set_has_country();
+    country_ = country;
+  } else {
+    clear_has_country();
+    country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountBlob.country)
+}
+
+// optional uint32 preferred_region = 33;
+inline bool AccountBlob::has_preferred_region() const {
+  return (_has_bits_[0] & 0x00040000u) != 0;
+}
+inline void AccountBlob::set_has_preferred_region() {
+  _has_bits_[0] |= 0x00040000u;
+}
+inline void AccountBlob::clear_has_preferred_region() {
+  _has_bits_[0] &= ~0x00040000u;
+}
+inline void AccountBlob::clear_preferred_region() {
+  preferred_region_ = 0u;
+  clear_has_preferred_region();
+}
+inline ::google::protobuf::uint32 AccountBlob::preferred_region() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.preferred_region)
+  return preferred_region_;
+}
+inline void AccountBlob::set_preferred_region(::google::protobuf::uint32 value) {
+  set_has_preferred_region();
+  preferred_region_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.preferred_region)
+}
+
+// optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 34;
+inline bool AccountBlob::has_identity_check_status() const {
+  return (_has_bits_[0] & 0x00080000u) != 0;
+}
+inline void AccountBlob::set_has_identity_check_status() {
+  _has_bits_[0] |= 0x00080000u;
+}
+inline void AccountBlob::clear_has_identity_check_status() {
+  _has_bits_[0] &= ~0x00080000u;
+}
+inline void AccountBlob::clear_identity_check_status() {
+  identity_check_status_ = 0;
+  clear_has_identity_check_status();
+}
+inline ::bgs::protocol::account::v1::IdentityVerificationStatus AccountBlob::identity_check_status() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlob.identity_check_status)
+  return static_cast< ::bgs::protocol::account::v1::IdentityVerificationStatus >(identity_check_status_);
+}
+inline void AccountBlob::set_identity_check_status(::bgs::protocol::account::v1::IdentityVerificationStatus value) {
+  assert(::bgs::protocol::account::v1::IdentityVerificationStatus_IsValid(value));
+  set_has_identity_check_status();
+  identity_check_status_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountBlob.identity_check_status)
+}
+
+// -------------------------------------------------------------------
+
+// AccountBlobList
+
+// repeated .bgs.protocol.account.v1.AccountBlob blob = 1;
+inline int AccountBlobList::blob_size() const {
+  return blob_.size();
+}
+inline void AccountBlobList::clear_blob() {
+  blob_.Clear();
+}
+inline const ::bgs::protocol::account::v1::AccountBlob& AccountBlobList::blob(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountBlobList.blob)
+  return blob_.Get(index);
+}
+inline ::bgs::protocol::account::v1::AccountBlob* AccountBlobList::mutable_blob(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountBlobList.blob)
+  return blob_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::AccountBlob* AccountBlobList::add_blob() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountBlobList.blob)
+  return blob_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountBlob >&
+AccountBlobList::blob() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountBlobList.blob)
+  return blob_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountBlob >*
+AccountBlobList::mutable_blob() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountBlobList.blob)
+  return &blob_;
+}
+
+// -------------------------------------------------------------------
+
+// GameAccountHandle
+
+// required fixed32 id = 1;
+inline bool GameAccountHandle::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameAccountHandle::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameAccountHandle::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameAccountHandle::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 GameAccountHandle::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountHandle.id)
+  return id_;
+}
+inline void GameAccountHandle::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountHandle.id)
+}
+
+// required fixed32 program = 2;
+inline bool GameAccountHandle::has_program() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameAccountHandle::set_has_program() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameAccountHandle::clear_has_program() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameAccountHandle::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 GameAccountHandle::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountHandle.program)
+  return program_;
+}
+inline void GameAccountHandle::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountHandle.program)
+}
+
+// required uint32 region = 3;
+inline bool GameAccountHandle::has_region() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GameAccountHandle::set_has_region() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GameAccountHandle::clear_has_region() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GameAccountHandle::clear_region() {
+  region_ = 0u;
+  clear_has_region();
+}
+inline ::google::protobuf::uint32 GameAccountHandle::region() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountHandle.region)
+  return region_;
+}
+inline void GameAccountHandle::set_region(::google::protobuf::uint32 value) {
+  set_has_region();
+  region_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountHandle.region)
+}
+
+// -------------------------------------------------------------------
+
+// GameAccountLink
+
+// required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+inline bool GameAccountLink::has_game_account() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameAccountLink::set_has_game_account() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameAccountLink::clear_has_game_account() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameAccountLink::clear_game_account() {
+  if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
+  clear_has_game_account();
+}
+inline const ::bgs::protocol::account::v1::GameAccountHandle& GameAccountLink::game_account() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountLink.game_account)
+  return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_;
+}
+inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountLink::mutable_game_account() {
+  set_has_game_account();
+  if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountLink.game_account)
+  return game_account_;
+}
+inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountLink::release_game_account() {
+  clear_has_game_account();
+  ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_;
+  game_account_ = NULL;
+  return temp;
+}
+inline void GameAccountLink::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) {
+  delete game_account_;
+  game_account_ = game_account;
+  if (game_account) {
+    set_has_game_account();
+  } else {
+    clear_has_game_account();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountLink.game_account)
+}
+
+// required string name = 2;
+inline bool GameAccountLink::has_name() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameAccountLink::set_has_name() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameAccountLink::clear_has_name() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameAccountLink::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& GameAccountLink::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountLink.name)
+  return *name_;
+}
+inline void GameAccountLink::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountLink.name)
+}
+inline void GameAccountLink::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GameAccountLink.name)
+}
+inline void GameAccountLink::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GameAccountLink.name)
+}
+inline ::std::string* GameAccountLink::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountLink.name)
+  return name_;
+}
+inline ::std::string* GameAccountLink::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void GameAccountLink::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountLink.name)
+}
+
+// -------------------------------------------------------------------
+
+// GameAccountBlob
+
+// required .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
+inline bool GameAccountBlob::has_game_account() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameAccountBlob::set_has_game_account() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameAccountBlob::clear_has_game_account() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameAccountBlob::clear_game_account() {
+  if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
+  clear_has_game_account();
+}
+inline const ::bgs::protocol::account::v1::GameAccountHandle& GameAccountBlob::game_account() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.game_account)
+  return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_;
+}
+inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountBlob::mutable_game_account() {
+  set_has_game_account();
+  if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountBlob.game_account)
+  return game_account_;
+}
+inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountBlob::release_game_account() {
+  clear_has_game_account();
+  ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_;
+  game_account_ = NULL;
+  return temp;
+}
+inline void GameAccountBlob::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) {
+  delete game_account_;
+  game_account_ = game_account;
+  if (game_account) {
+    set_has_game_account();
+  } else {
+    clear_has_game_account();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountBlob.game_account)
+}
+
+// optional string name = 2 [default = ""];
+inline bool GameAccountBlob::has_name() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameAccountBlob::set_has_name() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameAccountBlob::clear_has_name() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameAccountBlob::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& GameAccountBlob::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.name)
+  return *name_;
+}
+inline void GameAccountBlob::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.name)
+}
+inline void GameAccountBlob::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GameAccountBlob.name)
+}
+inline void GameAccountBlob::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GameAccountBlob.name)
+}
+inline ::std::string* GameAccountBlob::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountBlob.name)
+  return name_;
+}
+inline ::std::string* GameAccountBlob::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void GameAccountBlob::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountBlob.name)
+}
+
+// optional uint32 realm_permissions = 3 [default = 0];
+inline bool GameAccountBlob::has_realm_permissions() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GameAccountBlob::set_has_realm_permissions() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GameAccountBlob::clear_has_realm_permissions() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GameAccountBlob::clear_realm_permissions() {
+  realm_permissions_ = 0u;
+  clear_has_realm_permissions();
+}
+inline ::google::protobuf::uint32 GameAccountBlob::realm_permissions() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.realm_permissions)
+  return realm_permissions_;
+}
+inline void GameAccountBlob::set_realm_permissions(::google::protobuf::uint32 value) {
+  set_has_realm_permissions();
+  realm_permissions_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.realm_permissions)
+}
+
+// required uint32 status = 4;
+inline bool GameAccountBlob::has_status() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GameAccountBlob::set_has_status() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GameAccountBlob::clear_has_status() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GameAccountBlob::clear_status() {
+  status_ = 0u;
+  clear_has_status();
+}
+inline ::google::protobuf::uint32 GameAccountBlob::status() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.status)
+  return status_;
+}
+inline void GameAccountBlob::set_status(::google::protobuf::uint32 value) {
+  set_has_status();
+  status_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.status)
+}
+
+// optional uint64 flags = 5 [default = 0];
+inline bool GameAccountBlob::has_flags() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void GameAccountBlob::set_has_flags() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void GameAccountBlob::clear_has_flags() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void GameAccountBlob::clear_flags() {
+  flags_ = GOOGLE_ULONGLONG(0);
+  clear_has_flags();
+}
+inline ::google::protobuf::uint64 GameAccountBlob::flags() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.flags)
+  return flags_;
+}
+inline void GameAccountBlob::set_flags(::google::protobuf::uint64 value) {
+  set_has_flags();
+  flags_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.flags)
+}
+
+// optional uint32 billing_flags = 6 [default = 0];
+inline bool GameAccountBlob::has_billing_flags() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void GameAccountBlob::set_has_billing_flags() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void GameAccountBlob::clear_has_billing_flags() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void GameAccountBlob::clear_billing_flags() {
+  billing_flags_ = 0u;
+  clear_has_billing_flags();
+}
+inline ::google::protobuf::uint32 GameAccountBlob::billing_flags() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.billing_flags)
+  return billing_flags_;
+}
+inline void GameAccountBlob::set_billing_flags(::google::protobuf::uint32 value) {
+  set_has_billing_flags();
+  billing_flags_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.billing_flags)
+}
+
+// required uint64 cache_expiration = 7;
+inline bool GameAccountBlob::has_cache_expiration() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void GameAccountBlob::set_has_cache_expiration() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void GameAccountBlob::clear_has_cache_expiration() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void GameAccountBlob::clear_cache_expiration() {
+  cache_expiration_ = GOOGLE_ULONGLONG(0);
+  clear_has_cache_expiration();
+}
+inline ::google::protobuf::uint64 GameAccountBlob::cache_expiration() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.cache_expiration)
+  return cache_expiration_;
+}
+inline void GameAccountBlob::set_cache_expiration(::google::protobuf::uint64 value) {
+  set_has_cache_expiration();
+  cache_expiration_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.cache_expiration)
+}
+
+// optional uint64 subscription_expiration = 10;
+inline bool GameAccountBlob::has_subscription_expiration() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void GameAccountBlob::set_has_subscription_expiration() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void GameAccountBlob::clear_has_subscription_expiration() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void GameAccountBlob::clear_subscription_expiration() {
+  subscription_expiration_ = GOOGLE_ULONGLONG(0);
+  clear_has_subscription_expiration();
+}
+inline ::google::protobuf::uint64 GameAccountBlob::subscription_expiration() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.subscription_expiration)
+  return subscription_expiration_;
+}
+inline void GameAccountBlob::set_subscription_expiration(::google::protobuf::uint64 value) {
+  set_has_subscription_expiration();
+  subscription_expiration_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.subscription_expiration)
+}
+
+// optional uint32 units_remaining = 11;
+inline bool GameAccountBlob::has_units_remaining() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void GameAccountBlob::set_has_units_remaining() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void GameAccountBlob::clear_has_units_remaining() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void GameAccountBlob::clear_units_remaining() {
+  units_remaining_ = 0u;
+  clear_has_units_remaining();
+}
+inline ::google::protobuf::uint32 GameAccountBlob::units_remaining() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.units_remaining)
+  return units_remaining_;
+}
+inline void GameAccountBlob::set_units_remaining(::google::protobuf::uint32 value) {
+  set_has_units_remaining();
+  units_remaining_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.units_remaining)
+}
+
+// optional uint64 status_expiration = 12;
+inline bool GameAccountBlob::has_status_expiration() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void GameAccountBlob::set_has_status_expiration() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void GameAccountBlob::clear_has_status_expiration() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void GameAccountBlob::clear_status_expiration() {
+  status_expiration_ = GOOGLE_ULONGLONG(0);
+  clear_has_status_expiration();
+}
+inline ::google::protobuf::uint64 GameAccountBlob::status_expiration() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.status_expiration)
+  return status_expiration_;
+}
+inline void GameAccountBlob::set_status_expiration(::google::protobuf::uint64 value) {
+  set_has_status_expiration();
+  status_expiration_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.status_expiration)
+}
+
+// optional uint32 box_level = 13;
+inline bool GameAccountBlob::has_box_level() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void GameAccountBlob::set_has_box_level() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void GameAccountBlob::clear_has_box_level() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void GameAccountBlob::clear_box_level() {
+  box_level_ = 0u;
+  clear_has_box_level();
+}
+inline ::google::protobuf::uint32 GameAccountBlob::box_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.box_level)
+  return box_level_;
+}
+inline void GameAccountBlob::set_box_level(::google::protobuf::uint32 value) {
+  set_has_box_level();
+  box_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.box_level)
+}
+
+// optional uint64 box_level_expiration = 14;
+inline bool GameAccountBlob::has_box_level_expiration() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void GameAccountBlob::set_has_box_level_expiration() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void GameAccountBlob::clear_has_box_level_expiration() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void GameAccountBlob::clear_box_level_expiration() {
+  box_level_expiration_ = GOOGLE_ULONGLONG(0);
+  clear_has_box_level_expiration();
+}
+inline ::google::protobuf::uint64 GameAccountBlob::box_level_expiration() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.box_level_expiration)
+  return box_level_expiration_;
+}
+inline void GameAccountBlob::set_box_level_expiration(::google::protobuf::uint64 value) {
+  set_has_box_level_expiration();
+  box_level_expiration_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.box_level_expiration)
+}
+
+// repeated .bgs.protocol.account.v1.AccountLicense licenses = 20;
+inline int GameAccountBlob::licenses_size() const {
+  return licenses_.size();
+}
+inline void GameAccountBlob::clear_licenses() {
+  licenses_.Clear();
+}
+inline const ::bgs::protocol::account::v1::AccountLicense& GameAccountBlob::licenses(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.licenses)
+  return licenses_.Get(index);
+}
+inline ::bgs::protocol::account::v1::AccountLicense* GameAccountBlob::mutable_licenses(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountBlob.licenses)
+  return licenses_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::AccountLicense* GameAccountBlob::add_licenses() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GameAccountBlob.licenses)
+  return licenses_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >&
+GameAccountBlob::licenses() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GameAccountBlob.licenses)
+  return licenses_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >*
+GameAccountBlob::mutable_licenses() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GameAccountBlob.licenses)
+  return &licenses_;
+}
+
+// optional fixed32 raf_account = 21;
+inline bool GameAccountBlob::has_raf_account() const {
+  return (_has_bits_[0] & 0x00002000u) != 0;
+}
+inline void GameAccountBlob::set_has_raf_account() {
+  _has_bits_[0] |= 0x00002000u;
+}
+inline void GameAccountBlob::clear_has_raf_account() {
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline void GameAccountBlob::clear_raf_account() {
+  raf_account_ = 0u;
+  clear_has_raf_account();
+}
+inline ::google::protobuf::uint32 GameAccountBlob::raf_account() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.raf_account)
+  return raf_account_;
+}
+inline void GameAccountBlob::set_raf_account(::google::protobuf::uint32 value) {
+  set_has_raf_account();
+  raf_account_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.raf_account)
+}
+
+// optional bytes raf_info = 22;
+inline bool GameAccountBlob::has_raf_info() const {
+  return (_has_bits_[0] & 0x00004000u) != 0;
+}
+inline void GameAccountBlob::set_has_raf_info() {
+  _has_bits_[0] |= 0x00004000u;
+}
+inline void GameAccountBlob::clear_has_raf_info() {
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline void GameAccountBlob::clear_raf_info() {
+  if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raf_info_->clear();
+  }
+  clear_has_raf_info();
+}
+inline const ::std::string& GameAccountBlob::raf_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.raf_info)
+  return *raf_info_;
+}
+inline void GameAccountBlob::set_raf_info(const ::std::string& value) {
+  set_has_raf_info();
+  if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raf_info_ = new ::std::string;
+  }
+  raf_info_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.raf_info)
+}
+inline void GameAccountBlob::set_raf_info(const char* value) {
+  set_has_raf_info();
+  if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raf_info_ = new ::std::string;
+  }
+  raf_info_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GameAccountBlob.raf_info)
+}
+inline void GameAccountBlob::set_raf_info(const void* value, size_t size) {
+  set_has_raf_info();
+  if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raf_info_ = new ::std::string;
+  }
+  raf_info_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GameAccountBlob.raf_info)
+}
+inline ::std::string* GameAccountBlob::mutable_raf_info() {
+  set_has_raf_info();
+  if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raf_info_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountBlob.raf_info)
+  return raf_info_;
+}
+inline ::std::string* GameAccountBlob::release_raf_info() {
+  clear_has_raf_info();
+  if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = raf_info_;
+    raf_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void GameAccountBlob::set_allocated_raf_info(::std::string* raf_info) {
+  if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete raf_info_;
+  }
+  if (raf_info) {
+    set_has_raf_info();
+    raf_info_ = raf_info;
+  } else {
+    clear_has_raf_info();
+    raf_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountBlob.raf_info)
+}
+
+// optional uint64 raf_expiration = 23;
+inline bool GameAccountBlob::has_raf_expiration() const {
+  return (_has_bits_[0] & 0x00008000u) != 0;
+}
+inline void GameAccountBlob::set_has_raf_expiration() {
+  _has_bits_[0] |= 0x00008000u;
+}
+inline void GameAccountBlob::clear_has_raf_expiration() {
+  _has_bits_[0] &= ~0x00008000u;
+}
+inline void GameAccountBlob::clear_raf_expiration() {
+  raf_expiration_ = GOOGLE_ULONGLONG(0);
+  clear_has_raf_expiration();
+}
+inline ::google::protobuf::uint64 GameAccountBlob::raf_expiration() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlob.raf_expiration)
+  return raf_expiration_;
+}
+inline void GameAccountBlob::set_raf_expiration(::google::protobuf::uint64 value) {
+  set_has_raf_expiration();
+  raf_expiration_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountBlob.raf_expiration)
+}
+
+// -------------------------------------------------------------------
+
+// GameAccountBlobList
+
+// repeated .bgs.protocol.account.v1.GameAccountBlob blob = 1;
+inline int GameAccountBlobList::blob_size() const {
+  return blob_.size();
+}
+inline void GameAccountBlobList::clear_blob() {
+  blob_.Clear();
+}
+inline const ::bgs::protocol::account::v1::GameAccountBlob& GameAccountBlobList::blob(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountBlobList.blob)
+  return blob_.Get(index);
+}
+inline ::bgs::protocol::account::v1::GameAccountBlob* GameAccountBlobList::mutable_blob(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountBlobList.blob)
+  return blob_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::GameAccountBlob* GameAccountBlobList::add_blob() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GameAccountBlobList.blob)
+  return blob_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountBlob >&
+GameAccountBlobList::blob() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GameAccountBlobList.blob)
+  return blob_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountBlob >*
+GameAccountBlobList::mutable_blob() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GameAccountBlobList.blob)
+  return &blob_;
+}
+
+// -------------------------------------------------------------------
+
+// AccountReference
+
+// optional fixed32 id = 1;
+inline bool AccountReference::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AccountReference::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AccountReference::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AccountReference::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 AccountReference::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountReference.id)
+  return id_;
+}
+inline void AccountReference::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountReference.id)
+}
+
+// optional string email = 2;
+inline bool AccountReference::has_email() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AccountReference::set_has_email() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AccountReference::clear_has_email() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AccountReference::clear_email() {
+  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    email_->clear();
+  }
+  clear_has_email();
+}
+inline const ::std::string& AccountReference::email() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountReference.email)
+  return *email_;
+}
+inline void AccountReference::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.account.v1.AccountReference.email)
+}
+inline void AccountReference::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.account.v1.AccountReference.email)
+}
+inline void AccountReference::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.account.v1.AccountReference.email)
+}
+inline ::std::string* AccountReference::mutable_email() {
+  set_has_email();
+  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    email_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountReference.email)
+  return email_;
+}
+inline ::std::string* AccountReference::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 AccountReference::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.account.v1.AccountReference.email)
+}
+
+// optional .bgs.protocol.account.v1.GameAccountHandle handle = 3;
+inline bool AccountReference::has_handle() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AccountReference::set_has_handle() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AccountReference::clear_has_handle() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AccountReference::clear_handle() {
+  if (handle_ != NULL) handle_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
+  clear_has_handle();
+}
+inline const ::bgs::protocol::account::v1::GameAccountHandle& AccountReference::handle() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountReference.handle)
+  return handle_ != NULL ? *handle_ : *default_instance_->handle_;
+}
+inline ::bgs::protocol::account::v1::GameAccountHandle* AccountReference::mutable_handle() {
+  set_has_handle();
+  if (handle_ == NULL) handle_ = new ::bgs::protocol::account::v1::GameAccountHandle;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountReference.handle)
+  return handle_;
+}
+inline ::bgs::protocol::account::v1::GameAccountHandle* AccountReference::release_handle() {
+  clear_has_handle();
+  ::bgs::protocol::account::v1::GameAccountHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline void AccountReference::set_allocated_handle(::bgs::protocol::account::v1::GameAccountHandle* handle) {
+  delete handle_;
+  handle_ = handle;
+  if (handle) {
+    set_has_handle();
+  } else {
+    clear_has_handle();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountReference.handle)
+}
+
+// optional string battle_tag = 4;
+inline bool AccountReference::has_battle_tag() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void AccountReference::set_has_battle_tag() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void AccountReference::clear_has_battle_tag() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void AccountReference::clear_battle_tag() {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_->clear();
+  }
+  clear_has_battle_tag();
+}
+inline const ::std::string& AccountReference::battle_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountReference.battle_tag)
+  return *battle_tag_;
+}
+inline void AccountReference::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.account.v1.AccountReference.battle_tag)
+}
+inline void AccountReference::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.account.v1.AccountReference.battle_tag)
+}
+inline void AccountReference::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.account.v1.AccountReference.battle_tag)
+}
+inline ::std::string* AccountReference::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.account.v1.AccountReference.battle_tag)
+  return battle_tag_;
+}
+inline ::std::string* AccountReference::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 AccountReference::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.account.v1.AccountReference.battle_tag)
+}
+
+// optional uint32 region = 10 [default = 0];
+inline bool AccountReference::has_region() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void AccountReference::set_has_region() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void AccountReference::clear_has_region() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void AccountReference::clear_region() {
+  region_ = 0u;
+  clear_has_region();
+}
+inline ::google::protobuf::uint32 AccountReference::region() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountReference.region)
+  return region_;
+}
+inline void AccountReference::set_region(::google::protobuf::uint32 value) {
+  set_has_region();
+  region_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountReference.region)
+}
+
+// -------------------------------------------------------------------
+
+// Identity
+
+// optional .bgs.protocol.account.v1.AccountId account = 1;
+inline bool Identity::has_account() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Identity::set_has_account() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Identity::clear_has_account() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Identity::clear_account() {
+  if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
+  clear_has_account();
+}
+inline const ::bgs::protocol::account::v1::AccountId& Identity::account() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.Identity.account)
+  return account_ != NULL ? *account_ : *default_instance_->account_;
+}
+inline ::bgs::protocol::account::v1::AccountId* Identity::mutable_account() {
+  set_has_account();
+  if (account_ == NULL) account_ = new ::bgs::protocol::account::v1::AccountId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.Identity.account)
+  return account_;
+}
+inline ::bgs::protocol::account::v1::AccountId* Identity::release_account() {
+  clear_has_account();
+  ::bgs::protocol::account::v1::AccountId* temp = account_;
+  account_ = NULL;
+  return temp;
+}
+inline void Identity::set_allocated_account(::bgs::protocol::account::v1::AccountId* account) {
+  delete account_;
+  account_ = account;
+  if (account) {
+    set_has_account();
+  } else {
+    clear_has_account();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.Identity.account)
+}
+
+// optional .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
+inline bool Identity::has_game_account() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Identity::set_has_game_account() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Identity::clear_has_game_account() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Identity::clear_game_account() {
+  if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
+  clear_has_game_account();
+}
+inline const ::bgs::protocol::account::v1::GameAccountHandle& Identity::game_account() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.Identity.game_account)
+  return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_;
+}
+inline ::bgs::protocol::account::v1::GameAccountHandle* Identity::mutable_game_account() {
+  set_has_game_account();
+  if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.Identity.game_account)
+  return game_account_;
+}
+inline ::bgs::protocol::account::v1::GameAccountHandle* Identity::release_game_account() {
+  clear_has_game_account();
+  ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_;
+  game_account_ = NULL;
+  return temp;
+}
+inline void Identity::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) {
+  delete game_account_;
+  game_account_ = game_account;
+  if (game_account) {
+    set_has_game_account();
+  } else {
+    clear_has_game_account();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.Identity.game_account)
+}
+
+// optional .bgs.protocol.ProcessId process = 3;
+inline bool Identity::has_process() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Identity::set_has_process() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Identity::clear_has_process() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Identity::clear_process() {
+  if (process_ != NULL) process_->::bgs::protocol::ProcessId::Clear();
+  clear_has_process();
+}
+inline const ::bgs::protocol::ProcessId& Identity::process() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.Identity.process)
+  return process_ != NULL ? *process_ : *default_instance_->process_;
+}
+inline ::bgs::protocol::ProcessId* Identity::mutable_process() {
+  set_has_process();
+  if (process_ == NULL) process_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.Identity.process)
+  return process_;
+}
+inline ::bgs::protocol::ProcessId* Identity::release_process() {
+  clear_has_process();
+  ::bgs::protocol::ProcessId* temp = process_;
+  process_ = NULL;
+  return temp;
+}
+inline void Identity::set_allocated_process(::bgs::protocol::ProcessId* process) {
+  delete process_;
+  process_ = process;
+  if (process) {
+    set_has_process();
+  } else {
+    clear_has_process();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.Identity.process)
+}
+
+// -------------------------------------------------------------------
+
+// ProgramTag
+
+// optional fixed32 program = 1;
+inline bool ProgramTag::has_program() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ProgramTag::set_has_program() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ProgramTag::clear_has_program() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ProgramTag::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 ProgramTag::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ProgramTag.program)
+  return program_;
+}
+inline void ProgramTag::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ProgramTag.program)
+}
+
+// optional fixed32 tag = 2;
+inline bool ProgramTag::has_tag() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ProgramTag::set_has_tag() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ProgramTag::clear_has_tag() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ProgramTag::clear_tag() {
+  tag_ = 0u;
+  clear_has_tag();
+}
+inline ::google::protobuf::uint32 ProgramTag::tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ProgramTag.tag)
+  return tag_;
+}
+inline void ProgramTag::set_tag(::google::protobuf::uint32 value) {
+  set_has_tag();
+  tag_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ProgramTag.tag)
+}
+
+// -------------------------------------------------------------------
+
+// RegionTag
+
+// optional fixed32 region = 1;
+inline bool RegionTag::has_region() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RegionTag::set_has_region() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RegionTag::clear_has_region() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RegionTag::clear_region() {
+  region_ = 0u;
+  clear_has_region();
+}
+inline ::google::protobuf::uint32 RegionTag::region() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.RegionTag.region)
+  return region_;
+}
+inline void RegionTag::set_region(::google::protobuf::uint32 value) {
+  set_has_region();
+  region_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.RegionTag.region)
+}
+
+// optional fixed32 tag = 2;
+inline bool RegionTag::has_tag() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RegionTag::set_has_tag() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RegionTag::clear_has_tag() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RegionTag::clear_tag() {
+  tag_ = 0u;
+  clear_has_tag();
+}
+inline ::google::protobuf::uint32 RegionTag::tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.RegionTag.tag)
+  return tag_;
+}
+inline void RegionTag::set_tag(::google::protobuf::uint32 value) {
+  set_has_tag();
+  tag_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.RegionTag.tag)
+}
+
+// -------------------------------------------------------------------
+
+// AccountFieldTags
+
+// optional fixed32 account_level_info_tag = 2;
+inline bool AccountFieldTags::has_account_level_info_tag() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AccountFieldTags::set_has_account_level_info_tag() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AccountFieldTags::clear_has_account_level_info_tag() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AccountFieldTags::clear_account_level_info_tag() {
+  account_level_info_tag_ = 0u;
+  clear_has_account_level_info_tag();
+}
+inline ::google::protobuf::uint32 AccountFieldTags::account_level_info_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldTags.account_level_info_tag)
+  return account_level_info_tag_;
+}
+inline void AccountFieldTags::set_account_level_info_tag(::google::protobuf::uint32 value) {
+  set_has_account_level_info_tag();
+  account_level_info_tag_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldTags.account_level_info_tag)
+}
+
+// optional fixed32 privacy_info_tag = 3;
+inline bool AccountFieldTags::has_privacy_info_tag() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AccountFieldTags::set_has_privacy_info_tag() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AccountFieldTags::clear_has_privacy_info_tag() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AccountFieldTags::clear_privacy_info_tag() {
+  privacy_info_tag_ = 0u;
+  clear_has_privacy_info_tag();
+}
+inline ::google::protobuf::uint32 AccountFieldTags::privacy_info_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldTags.privacy_info_tag)
+  return privacy_info_tag_;
+}
+inline void AccountFieldTags::set_privacy_info_tag(::google::protobuf::uint32 value) {
+  set_has_privacy_info_tag();
+  privacy_info_tag_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldTags.privacy_info_tag)
+}
+
+// optional fixed32 parental_control_info_tag = 4;
+inline bool AccountFieldTags::has_parental_control_info_tag() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AccountFieldTags::set_has_parental_control_info_tag() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AccountFieldTags::clear_has_parental_control_info_tag() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AccountFieldTags::clear_parental_control_info_tag() {
+  parental_control_info_tag_ = 0u;
+  clear_has_parental_control_info_tag();
+}
+inline ::google::protobuf::uint32 AccountFieldTags::parental_control_info_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldTags.parental_control_info_tag)
+  return parental_control_info_tag_;
+}
+inline void AccountFieldTags::set_parental_control_info_tag(::google::protobuf::uint32 value) {
+  set_has_parental_control_info_tag();
+  parental_control_info_tag_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldTags.parental_control_info_tag)
+}
+
+// repeated .bgs.protocol.account.v1.ProgramTag game_level_info_tags = 7;
+inline int AccountFieldTags::game_level_info_tags_size() const {
+  return game_level_info_tags_.size();
+}
+inline void AccountFieldTags::clear_game_level_info_tags() {
+  game_level_info_tags_.Clear();
+}
+inline const ::bgs::protocol::account::v1::ProgramTag& AccountFieldTags::game_level_info_tags(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldTags.game_level_info_tags)
+  return game_level_info_tags_.Get(index);
+}
+inline ::bgs::protocol::account::v1::ProgramTag* AccountFieldTags::mutable_game_level_info_tags(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountFieldTags.game_level_info_tags)
+  return game_level_info_tags_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::ProgramTag* AccountFieldTags::add_game_level_info_tags() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountFieldTags.game_level_info_tags)
+  return game_level_info_tags_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag >&
+AccountFieldTags::game_level_info_tags() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountFieldTags.game_level_info_tags)
+  return game_level_info_tags_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag >*
+AccountFieldTags::mutable_game_level_info_tags() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountFieldTags.game_level_info_tags)
+  return &game_level_info_tags_;
+}
+
+// repeated .bgs.protocol.account.v1.ProgramTag game_status_tags = 9;
+inline int AccountFieldTags::game_status_tags_size() const {
+  return game_status_tags_.size();
+}
+inline void AccountFieldTags::clear_game_status_tags() {
+  game_status_tags_.Clear();
+}
+inline const ::bgs::protocol::account::v1::ProgramTag& AccountFieldTags::game_status_tags(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldTags.game_status_tags)
+  return game_status_tags_.Get(index);
+}
+inline ::bgs::protocol::account::v1::ProgramTag* AccountFieldTags::mutable_game_status_tags(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountFieldTags.game_status_tags)
+  return game_status_tags_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::ProgramTag* AccountFieldTags::add_game_status_tags() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountFieldTags.game_status_tags)
+  return game_status_tags_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag >&
+AccountFieldTags::game_status_tags() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountFieldTags.game_status_tags)
+  return game_status_tags_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::ProgramTag >*
+AccountFieldTags::mutable_game_status_tags() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountFieldTags.game_status_tags)
+  return &game_status_tags_;
+}
+
+// repeated .bgs.protocol.account.v1.RegionTag game_account_tags = 11;
+inline int AccountFieldTags::game_account_tags_size() const {
+  return game_account_tags_.size();
+}
+inline void AccountFieldTags::clear_game_account_tags() {
+  game_account_tags_.Clear();
+}
+inline const ::bgs::protocol::account::v1::RegionTag& AccountFieldTags::game_account_tags(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldTags.game_account_tags)
+  return game_account_tags_.Get(index);
+}
+inline ::bgs::protocol::account::v1::RegionTag* AccountFieldTags::mutable_game_account_tags(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountFieldTags.game_account_tags)
+  return game_account_tags_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::RegionTag* AccountFieldTags::add_game_account_tags() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountFieldTags.game_account_tags)
+  return game_account_tags_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::RegionTag >&
+AccountFieldTags::game_account_tags() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountFieldTags.game_account_tags)
+  return game_account_tags_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::RegionTag >*
+AccountFieldTags::mutable_game_account_tags() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountFieldTags.game_account_tags)
+  return &game_account_tags_;
+}
+
+// -------------------------------------------------------------------
+
+// GameAccountFieldTags
+
+// optional fixed32 game_level_info_tag = 2;
+inline bool GameAccountFieldTags::has_game_level_info_tag() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameAccountFieldTags::set_has_game_level_info_tag() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameAccountFieldTags::clear_has_game_level_info_tag() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameAccountFieldTags::clear_game_level_info_tag() {
+  game_level_info_tag_ = 0u;
+  clear_has_game_level_info_tag();
+}
+inline ::google::protobuf::uint32 GameAccountFieldTags::game_level_info_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldTags.game_level_info_tag)
+  return game_level_info_tag_;
+}
+inline void GameAccountFieldTags::set_game_level_info_tag(::google::protobuf::uint32 value) {
+  set_has_game_level_info_tag();
+  game_level_info_tag_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldTags.game_level_info_tag)
+}
+
+// optional fixed32 game_time_info_tag = 3;
+inline bool GameAccountFieldTags::has_game_time_info_tag() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameAccountFieldTags::set_has_game_time_info_tag() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameAccountFieldTags::clear_has_game_time_info_tag() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameAccountFieldTags::clear_game_time_info_tag() {
+  game_time_info_tag_ = 0u;
+  clear_has_game_time_info_tag();
+}
+inline ::google::protobuf::uint32 GameAccountFieldTags::game_time_info_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldTags.game_time_info_tag)
+  return game_time_info_tag_;
+}
+inline void GameAccountFieldTags::set_game_time_info_tag(::google::protobuf::uint32 value) {
+  set_has_game_time_info_tag();
+  game_time_info_tag_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldTags.game_time_info_tag)
+}
+
+// optional fixed32 game_status_tag = 4;
+inline bool GameAccountFieldTags::has_game_status_tag() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GameAccountFieldTags::set_has_game_status_tag() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GameAccountFieldTags::clear_has_game_status_tag() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GameAccountFieldTags::clear_game_status_tag() {
+  game_status_tag_ = 0u;
+  clear_has_game_status_tag();
+}
+inline ::google::protobuf::uint32 GameAccountFieldTags::game_status_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldTags.game_status_tag)
+  return game_status_tag_;
+}
+inline void GameAccountFieldTags::set_game_status_tag(::google::protobuf::uint32 value) {
+  set_has_game_status_tag();
+  game_status_tag_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldTags.game_status_tag)
+}
+
+// optional fixed32 raf_info_tag = 5;
+inline bool GameAccountFieldTags::has_raf_info_tag() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GameAccountFieldTags::set_has_raf_info_tag() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GameAccountFieldTags::clear_has_raf_info_tag() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GameAccountFieldTags::clear_raf_info_tag() {
+  raf_info_tag_ = 0u;
+  clear_has_raf_info_tag();
+}
+inline ::google::protobuf::uint32 GameAccountFieldTags::raf_info_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldTags.raf_info_tag)
+  return raf_info_tag_;
+}
+inline void GameAccountFieldTags::set_raf_info_tag(::google::protobuf::uint32 value) {
+  set_has_raf_info_tag();
+  raf_info_tag_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldTags.raf_info_tag)
+}
+
+// -------------------------------------------------------------------
+
+// AccountFieldOptions
+
+// optional bool all_fields = 1;
+inline bool AccountFieldOptions::has_all_fields() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AccountFieldOptions::set_has_all_fields() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AccountFieldOptions::clear_has_all_fields() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AccountFieldOptions::clear_all_fields() {
+  all_fields_ = false;
+  clear_has_all_fields();
+}
+inline bool AccountFieldOptions::all_fields() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldOptions.all_fields)
+  return all_fields_;
+}
+inline void AccountFieldOptions::set_all_fields(bool value) {
+  set_has_all_fields();
+  all_fields_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldOptions.all_fields)
+}
+
+// optional bool field_account_level_info = 2;
+inline bool AccountFieldOptions::has_field_account_level_info() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AccountFieldOptions::set_has_field_account_level_info() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AccountFieldOptions::clear_has_field_account_level_info() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AccountFieldOptions::clear_field_account_level_info() {
+  field_account_level_info_ = false;
+  clear_has_field_account_level_info();
+}
+inline bool AccountFieldOptions::field_account_level_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldOptions.field_account_level_info)
+  return field_account_level_info_;
+}
+inline void AccountFieldOptions::set_field_account_level_info(bool value) {
+  set_has_field_account_level_info();
+  field_account_level_info_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldOptions.field_account_level_info)
+}
+
+// optional bool field_privacy_info = 3;
+inline bool AccountFieldOptions::has_field_privacy_info() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AccountFieldOptions::set_has_field_privacy_info() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AccountFieldOptions::clear_has_field_privacy_info() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AccountFieldOptions::clear_field_privacy_info() {
+  field_privacy_info_ = false;
+  clear_has_field_privacy_info();
+}
+inline bool AccountFieldOptions::field_privacy_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldOptions.field_privacy_info)
+  return field_privacy_info_;
+}
+inline void AccountFieldOptions::set_field_privacy_info(bool value) {
+  set_has_field_privacy_info();
+  field_privacy_info_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldOptions.field_privacy_info)
+}
+
+// optional bool field_parental_control_info = 4;
+inline bool AccountFieldOptions::has_field_parental_control_info() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void AccountFieldOptions::set_has_field_parental_control_info() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void AccountFieldOptions::clear_has_field_parental_control_info() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void AccountFieldOptions::clear_field_parental_control_info() {
+  field_parental_control_info_ = false;
+  clear_has_field_parental_control_info();
+}
+inline bool AccountFieldOptions::field_parental_control_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldOptions.field_parental_control_info)
+  return field_parental_control_info_;
+}
+inline void AccountFieldOptions::set_field_parental_control_info(bool value) {
+  set_has_field_parental_control_info();
+  field_parental_control_info_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldOptions.field_parental_control_info)
+}
+
+// optional bool field_game_level_info = 6;
+inline bool AccountFieldOptions::has_field_game_level_info() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void AccountFieldOptions::set_has_field_game_level_info() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void AccountFieldOptions::clear_has_field_game_level_info() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void AccountFieldOptions::clear_field_game_level_info() {
+  field_game_level_info_ = false;
+  clear_has_field_game_level_info();
+}
+inline bool AccountFieldOptions::field_game_level_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldOptions.field_game_level_info)
+  return field_game_level_info_;
+}
+inline void AccountFieldOptions::set_field_game_level_info(bool value) {
+  set_has_field_game_level_info();
+  field_game_level_info_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldOptions.field_game_level_info)
+}
+
+// optional bool field_game_status = 7;
+inline bool AccountFieldOptions::has_field_game_status() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void AccountFieldOptions::set_has_field_game_status() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void AccountFieldOptions::clear_has_field_game_status() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void AccountFieldOptions::clear_field_game_status() {
+  field_game_status_ = false;
+  clear_has_field_game_status();
+}
+inline bool AccountFieldOptions::field_game_status() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldOptions.field_game_status)
+  return field_game_status_;
+}
+inline void AccountFieldOptions::set_field_game_status(bool value) {
+  set_has_field_game_status();
+  field_game_status_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldOptions.field_game_status)
+}
+
+// optional bool field_game_accounts = 8;
+inline bool AccountFieldOptions::has_field_game_accounts() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void AccountFieldOptions::set_has_field_game_accounts() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void AccountFieldOptions::clear_has_field_game_accounts() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void AccountFieldOptions::clear_field_game_accounts() {
+  field_game_accounts_ = false;
+  clear_has_field_game_accounts();
+}
+inline bool AccountFieldOptions::field_game_accounts() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldOptions.field_game_accounts)
+  return field_game_accounts_;
+}
+inline void AccountFieldOptions::set_field_game_accounts(bool value) {
+  set_has_field_game_accounts();
+  field_game_accounts_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldOptions.field_game_accounts)
+}
+
+// -------------------------------------------------------------------
+
+// GameAccountFieldOptions
+
+// optional bool all_fields = 1;
+inline bool GameAccountFieldOptions::has_all_fields() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameAccountFieldOptions::set_has_all_fields() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameAccountFieldOptions::clear_has_all_fields() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameAccountFieldOptions::clear_all_fields() {
+  all_fields_ = false;
+  clear_has_all_fields();
+}
+inline bool GameAccountFieldOptions::all_fields() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldOptions.all_fields)
+  return all_fields_;
+}
+inline void GameAccountFieldOptions::set_all_fields(bool value) {
+  set_has_all_fields();
+  all_fields_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldOptions.all_fields)
+}
+
+// optional bool field_game_level_info = 2;
+inline bool GameAccountFieldOptions::has_field_game_level_info() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameAccountFieldOptions::set_has_field_game_level_info() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameAccountFieldOptions::clear_has_field_game_level_info() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameAccountFieldOptions::clear_field_game_level_info() {
+  field_game_level_info_ = false;
+  clear_has_field_game_level_info();
+}
+inline bool GameAccountFieldOptions::field_game_level_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldOptions.field_game_level_info)
+  return field_game_level_info_;
+}
+inline void GameAccountFieldOptions::set_field_game_level_info(bool value) {
+  set_has_field_game_level_info();
+  field_game_level_info_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldOptions.field_game_level_info)
+}
+
+// optional bool field_game_time_info = 3;
+inline bool GameAccountFieldOptions::has_field_game_time_info() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GameAccountFieldOptions::set_has_field_game_time_info() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GameAccountFieldOptions::clear_has_field_game_time_info() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GameAccountFieldOptions::clear_field_game_time_info() {
+  field_game_time_info_ = false;
+  clear_has_field_game_time_info();
+}
+inline bool GameAccountFieldOptions::field_game_time_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldOptions.field_game_time_info)
+  return field_game_time_info_;
+}
+inline void GameAccountFieldOptions::set_field_game_time_info(bool value) {
+  set_has_field_game_time_info();
+  field_game_time_info_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldOptions.field_game_time_info)
+}
+
+// optional bool field_game_status = 4;
+inline bool GameAccountFieldOptions::has_field_game_status() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GameAccountFieldOptions::set_has_field_game_status() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GameAccountFieldOptions::clear_has_field_game_status() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GameAccountFieldOptions::clear_field_game_status() {
+  field_game_status_ = false;
+  clear_has_field_game_status();
+}
+inline bool GameAccountFieldOptions::field_game_status() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldOptions.field_game_status)
+  return field_game_status_;
+}
+inline void GameAccountFieldOptions::set_field_game_status(bool value) {
+  set_has_field_game_status();
+  field_game_status_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldOptions.field_game_status)
+}
+
+// optional bool field_raf_info = 5;
+inline bool GameAccountFieldOptions::has_field_raf_info() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void GameAccountFieldOptions::set_has_field_raf_info() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void GameAccountFieldOptions::clear_has_field_raf_info() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void GameAccountFieldOptions::clear_field_raf_info() {
+  field_raf_info_ = false;
+  clear_has_field_raf_info();
+}
+inline bool GameAccountFieldOptions::field_raf_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFieldOptions.field_raf_info)
+  return field_raf_info_;
+}
+inline void GameAccountFieldOptions::set_field_raf_info(bool value) {
+  set_has_field_raf_info();
+  field_raf_info_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFieldOptions.field_raf_info)
+}
+
+// -------------------------------------------------------------------
+
+// SubscriberReference
+
+// optional uint64 object_id = 1 [default = 0];
+inline bool SubscriberReference::has_object_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SubscriberReference::set_has_object_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SubscriberReference::clear_has_object_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SubscriberReference::clear_object_id() {
+  object_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_object_id();
+}
+inline ::google::protobuf::uint64 SubscriberReference::object_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriberReference.object_id)
+  return object_id_;
+}
+inline void SubscriberReference::set_object_id(::google::protobuf::uint64 value) {
+  set_has_object_id();
+  object_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.SubscriberReference.object_id)
+}
+
+// optional .bgs.protocol.EntityId entity_id = 2;
+inline bool SubscriberReference::has_entity_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SubscriberReference::set_has_entity_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SubscriberReference::clear_has_entity_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SubscriberReference::clear_entity_id() {
+  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id();
+}
+inline const ::bgs::protocol::EntityId& SubscriberReference::entity_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriberReference.entity_id)
+  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
+}
+inline ::bgs::protocol::EntityId* SubscriberReference::mutable_entity_id() {
+  set_has_entity_id();
+  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.SubscriberReference.entity_id)
+  return entity_id_;
+}
+inline ::bgs::protocol::EntityId* SubscriberReference::release_entity_id() {
+  clear_has_entity_id();
+  ::bgs::protocol::EntityId* temp = entity_id_;
+  entity_id_ = NULL;
+  return temp;
+}
+inline void SubscriberReference::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
+  delete entity_id_;
+  entity_id_ = entity_id;
+  if (entity_id) {
+    set_has_entity_id();
+  } else {
+    clear_has_entity_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.SubscriberReference.entity_id)
+}
+
+// optional .bgs.protocol.account.v1.AccountFieldOptions account_options = 3;
+inline bool SubscriberReference::has_account_options() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SubscriberReference::set_has_account_options() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SubscriberReference::clear_has_account_options() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SubscriberReference::clear_account_options() {
+  if (account_options_ != NULL) account_options_->::bgs::protocol::account::v1::AccountFieldOptions::Clear();
+  clear_has_account_options();
+}
+inline const ::bgs::protocol::account::v1::AccountFieldOptions& SubscriberReference::account_options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriberReference.account_options)
+  return account_options_ != NULL ? *account_options_ : *default_instance_->account_options_;
+}
+inline ::bgs::protocol::account::v1::AccountFieldOptions* SubscriberReference::mutable_account_options() {
+  set_has_account_options();
+  if (account_options_ == NULL) account_options_ = new ::bgs::protocol::account::v1::AccountFieldOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.SubscriberReference.account_options)
+  return account_options_;
+}
+inline ::bgs::protocol::account::v1::AccountFieldOptions* SubscriberReference::release_account_options() {
+  clear_has_account_options();
+  ::bgs::protocol::account::v1::AccountFieldOptions* temp = account_options_;
+  account_options_ = NULL;
+  return temp;
+}
+inline void SubscriberReference::set_allocated_account_options(::bgs::protocol::account::v1::AccountFieldOptions* account_options) {
+  delete account_options_;
+  account_options_ = account_options;
+  if (account_options) {
+    set_has_account_options();
+  } else {
+    clear_has_account_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.SubscriberReference.account_options)
+}
+
+// optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 4;
+inline bool SubscriberReference::has_account_tags() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void SubscriberReference::set_has_account_tags() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void SubscriberReference::clear_has_account_tags() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void SubscriberReference::clear_account_tags() {
+  if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear();
+  clear_has_account_tags();
+}
+inline const ::bgs::protocol::account::v1::AccountFieldTags& SubscriberReference::account_tags() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriberReference.account_tags)
+  return account_tags_ != NULL ? *account_tags_ : *default_instance_->account_tags_;
+}
+inline ::bgs::protocol::account::v1::AccountFieldTags* SubscriberReference::mutable_account_tags() {
+  set_has_account_tags();
+  if (account_tags_ == NULL) account_tags_ = new ::bgs::protocol::account::v1::AccountFieldTags;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.SubscriberReference.account_tags)
+  return account_tags_;
+}
+inline ::bgs::protocol::account::v1::AccountFieldTags* SubscriberReference::release_account_tags() {
+  clear_has_account_tags();
+  ::bgs::protocol::account::v1::AccountFieldTags* temp = account_tags_;
+  account_tags_ = NULL;
+  return temp;
+}
+inline void SubscriberReference::set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags) {
+  delete account_tags_;
+  account_tags_ = account_tags;
+  if (account_tags) {
+    set_has_account_tags();
+  } else {
+    clear_has_account_tags();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.SubscriberReference.account_tags)
+}
+
+// optional .bgs.protocol.account.v1.GameAccountFieldOptions game_account_options = 5;
+inline bool SubscriberReference::has_game_account_options() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void SubscriberReference::set_has_game_account_options() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void SubscriberReference::clear_has_game_account_options() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void SubscriberReference::clear_game_account_options() {
+  if (game_account_options_ != NULL) game_account_options_->::bgs::protocol::account::v1::GameAccountFieldOptions::Clear();
+  clear_has_game_account_options();
+}
+inline const ::bgs::protocol::account::v1::GameAccountFieldOptions& SubscriberReference::game_account_options() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriberReference.game_account_options)
+  return game_account_options_ != NULL ? *game_account_options_ : *default_instance_->game_account_options_;
+}
+inline ::bgs::protocol::account::v1::GameAccountFieldOptions* SubscriberReference::mutable_game_account_options() {
+  set_has_game_account_options();
+  if (game_account_options_ == NULL) game_account_options_ = new ::bgs::protocol::account::v1::GameAccountFieldOptions;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.SubscriberReference.game_account_options)
+  return game_account_options_;
+}
+inline ::bgs::protocol::account::v1::GameAccountFieldOptions* SubscriberReference::release_game_account_options() {
+  clear_has_game_account_options();
+  ::bgs::protocol::account::v1::GameAccountFieldOptions* temp = game_account_options_;
+  game_account_options_ = NULL;
+  return temp;
+}
+inline void SubscriberReference::set_allocated_game_account_options(::bgs::protocol::account::v1::GameAccountFieldOptions* game_account_options) {
+  delete game_account_options_;
+  game_account_options_ = game_account_options;
+  if (game_account_options) {
+    set_has_game_account_options();
+  } else {
+    clear_has_game_account_options();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.SubscriberReference.game_account_options)
+}
+
+// optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 6;
+inline bool SubscriberReference::has_game_account_tags() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void SubscriberReference::set_has_game_account_tags() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void SubscriberReference::clear_has_game_account_tags() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void SubscriberReference::clear_game_account_tags() {
+  if (game_account_tags_ != NULL) game_account_tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear();
+  clear_has_game_account_tags();
+}
+inline const ::bgs::protocol::account::v1::GameAccountFieldTags& SubscriberReference::game_account_tags() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriberReference.game_account_tags)
+  return game_account_tags_ != NULL ? *game_account_tags_ : *default_instance_->game_account_tags_;
+}
+inline ::bgs::protocol::account::v1::GameAccountFieldTags* SubscriberReference::mutable_game_account_tags() {
+  set_has_game_account_tags();
+  if (game_account_tags_ == NULL) game_account_tags_ = new ::bgs::protocol::account::v1::GameAccountFieldTags;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.SubscriberReference.game_account_tags)
+  return game_account_tags_;
+}
+inline ::bgs::protocol::account::v1::GameAccountFieldTags* SubscriberReference::release_game_account_tags() {
+  clear_has_game_account_tags();
+  ::bgs::protocol::account::v1::GameAccountFieldTags* temp = game_account_tags_;
+  game_account_tags_ = NULL;
+  return temp;
+}
+inline void SubscriberReference::set_allocated_game_account_tags(::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags) {
+  delete game_account_tags_;
+  game_account_tags_ = game_account_tags;
+  if (game_account_tags) {
+    set_has_game_account_tags();
+  } else {
+    clear_has_game_account_tags();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.SubscriberReference.game_account_tags)
+}
+
+// optional uint64 subscriber_id = 7 [default = 0];
+inline bool SubscriberReference::has_subscriber_id() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void SubscriberReference::set_has_subscriber_id() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void SubscriberReference::clear_has_subscriber_id() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void SubscriberReference::clear_subscriber_id() {
+  subscriber_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_subscriber_id();
+}
+inline ::google::protobuf::uint64 SubscriberReference::subscriber_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriberReference.subscriber_id)
+  return subscriber_id_;
+}
+inline void SubscriberReference::set_subscriber_id(::google::protobuf::uint64 value) {
+  set_has_subscriber_id();
+  subscriber_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.SubscriberReference.subscriber_id)
+}
+
+// -------------------------------------------------------------------
+
+// AccountLevelInfo
+
+// repeated .bgs.protocol.account.v1.AccountLicense licenses = 3;
+inline int AccountLevelInfo::licenses_size() const {
+  return licenses_.size();
+}
+inline void AccountLevelInfo::clear_licenses() {
+  licenses_.Clear();
+}
+inline const ::bgs::protocol::account::v1::AccountLicense& AccountLevelInfo::licenses(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.licenses)
+  return licenses_.Get(index);
+}
+inline ::bgs::protocol::account::v1::AccountLicense* AccountLevelInfo::mutable_licenses(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountLevelInfo.licenses)
+  return licenses_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::AccountLicense* AccountLevelInfo::add_licenses() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountLevelInfo.licenses)
+  return licenses_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >&
+AccountLevelInfo::licenses() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountLevelInfo.licenses)
+  return licenses_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >*
+AccountLevelInfo::mutable_licenses() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountLevelInfo.licenses)
+  return &licenses_;
+}
+
+// optional fixed32 default_currency = 4;
+inline bool AccountLevelInfo::has_default_currency() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AccountLevelInfo::set_has_default_currency() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AccountLevelInfo::clear_has_default_currency() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AccountLevelInfo::clear_default_currency() {
+  default_currency_ = 0u;
+  clear_has_default_currency();
+}
+inline ::google::protobuf::uint32 AccountLevelInfo::default_currency() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.default_currency)
+  return default_currency_;
+}
+inline void AccountLevelInfo::set_default_currency(::google::protobuf::uint32 value) {
+  set_has_default_currency();
+  default_currency_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.default_currency)
+}
+
+// optional string country = 5;
+inline bool AccountLevelInfo::has_country() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AccountLevelInfo::set_has_country() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AccountLevelInfo::clear_has_country() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AccountLevelInfo::clear_country() {
+  if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    country_->clear();
+  }
+  clear_has_country();
+}
+inline const ::std::string& AccountLevelInfo::country() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.country)
+  return *country_;
+}
+inline void AccountLevelInfo::set_country(const ::std::string& value) {
+  set_has_country();
+  if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    country_ = new ::std::string;
+  }
+  country_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.country)
+}
+inline void AccountLevelInfo::set_country(const char* value) {
+  set_has_country();
+  if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    country_ = new ::std::string;
+  }
+  country_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountLevelInfo.country)
+}
+inline void AccountLevelInfo::set_country(const char* value, size_t size) {
+  set_has_country();
+  if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    country_ = new ::std::string;
+  }
+  country_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountLevelInfo.country)
+}
+inline ::std::string* AccountLevelInfo::mutable_country() {
+  set_has_country();
+  if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    country_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountLevelInfo.country)
+  return country_;
+}
+inline ::std::string* AccountLevelInfo::release_country() {
+  clear_has_country();
+  if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = country_;
+    country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void AccountLevelInfo::set_allocated_country(::std::string* country) {
+  if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete country_;
+  }
+  if (country) {
+    set_has_country();
+    country_ = country;
+  } else {
+    clear_has_country();
+    country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountLevelInfo.country)
+}
+
+// optional uint32 preferred_region = 6;
+inline bool AccountLevelInfo::has_preferred_region() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void AccountLevelInfo::set_has_preferred_region() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void AccountLevelInfo::clear_has_preferred_region() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void AccountLevelInfo::clear_preferred_region() {
+  preferred_region_ = 0u;
+  clear_has_preferred_region();
+}
+inline ::google::protobuf::uint32 AccountLevelInfo::preferred_region() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.preferred_region)
+  return preferred_region_;
+}
+inline void AccountLevelInfo::set_preferred_region(::google::protobuf::uint32 value) {
+  set_has_preferred_region();
+  preferred_region_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.preferred_region)
+}
+
+// optional string full_name = 7;
+inline bool AccountLevelInfo::has_full_name() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void AccountLevelInfo::set_has_full_name() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void AccountLevelInfo::clear_has_full_name() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void AccountLevelInfo::clear_full_name() {
+  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_->clear();
+  }
+  clear_has_full_name();
+}
+inline const ::std::string& AccountLevelInfo::full_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.full_name)
+  return *full_name_;
+}
+inline void AccountLevelInfo::set_full_name(const ::std::string& value) {
+  set_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_ = new ::std::string;
+  }
+  full_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.full_name)
+}
+inline void AccountLevelInfo::set_full_name(const char* value) {
+  set_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_ = new ::std::string;
+  }
+  full_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountLevelInfo.full_name)
+}
+inline void AccountLevelInfo::set_full_name(const char* value, size_t size) {
+  set_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_ = new ::std::string;
+  }
+  full_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountLevelInfo.full_name)
+}
+inline ::std::string* AccountLevelInfo::mutable_full_name() {
+  set_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountLevelInfo.full_name)
+  return full_name_;
+}
+inline ::std::string* AccountLevelInfo::release_full_name() {
+  clear_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = full_name_;
+    full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void AccountLevelInfo::set_allocated_full_name(::std::string* full_name) {
+  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete full_name_;
+  }
+  if (full_name) {
+    set_has_full_name();
+    full_name_ = full_name;
+  } else {
+    clear_has_full_name();
+    full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountLevelInfo.full_name)
+}
+
+// optional string battle_tag = 8;
+inline bool AccountLevelInfo::has_battle_tag() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void AccountLevelInfo::set_has_battle_tag() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void AccountLevelInfo::clear_has_battle_tag() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void AccountLevelInfo::clear_battle_tag() {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_->clear();
+  }
+  clear_has_battle_tag();
+}
+inline const ::std::string& AccountLevelInfo::battle_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.battle_tag)
+  return *battle_tag_;
+}
+inline void AccountLevelInfo::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.account.v1.AccountLevelInfo.battle_tag)
+}
+inline void AccountLevelInfo::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.account.v1.AccountLevelInfo.battle_tag)
+}
+inline void AccountLevelInfo::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.account.v1.AccountLevelInfo.battle_tag)
+}
+inline ::std::string* AccountLevelInfo::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.account.v1.AccountLevelInfo.battle_tag)
+  return battle_tag_;
+}
+inline ::std::string* AccountLevelInfo::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 AccountLevelInfo::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.account.v1.AccountLevelInfo.battle_tag)
+}
+
+// optional bool muted = 9;
+inline bool AccountLevelInfo::has_muted() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void AccountLevelInfo::set_has_muted() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void AccountLevelInfo::clear_has_muted() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void AccountLevelInfo::clear_muted() {
+  muted_ = false;
+  clear_has_muted();
+}
+inline bool AccountLevelInfo::muted() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.muted)
+  return muted_;
+}
+inline void AccountLevelInfo::set_muted(bool value) {
+  set_has_muted();
+  muted_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.muted)
+}
+
+// optional bool manual_review = 10;
+inline bool AccountLevelInfo::has_manual_review() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void AccountLevelInfo::set_has_manual_review() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void AccountLevelInfo::clear_has_manual_review() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void AccountLevelInfo::clear_manual_review() {
+  manual_review_ = false;
+  clear_has_manual_review();
+}
+inline bool AccountLevelInfo::manual_review() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.manual_review)
+  return manual_review_;
+}
+inline void AccountLevelInfo::set_manual_review(bool value) {
+  set_has_manual_review();
+  manual_review_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.manual_review)
+}
+
+// optional bool account_paid_any = 11;
+inline bool AccountLevelInfo::has_account_paid_any() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void AccountLevelInfo::set_has_account_paid_any() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void AccountLevelInfo::clear_has_account_paid_any() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void AccountLevelInfo::clear_account_paid_any() {
+  account_paid_any_ = false;
+  clear_has_account_paid_any();
+}
+inline bool AccountLevelInfo::account_paid_any() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.account_paid_any)
+  return account_paid_any_;
+}
+inline void AccountLevelInfo::set_account_paid_any(bool value) {
+  set_has_account_paid_any();
+  account_paid_any_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.account_paid_any)
+}
+
+// optional .bgs.protocol.account.v1.IdentityVerificationStatus identity_check_status = 12;
+inline bool AccountLevelInfo::has_identity_check_status() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void AccountLevelInfo::set_has_identity_check_status() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void AccountLevelInfo::clear_has_identity_check_status() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void AccountLevelInfo::clear_identity_check_status() {
+  identity_check_status_ = 0;
+  clear_has_identity_check_status();
+}
+inline ::bgs::protocol::account::v1::IdentityVerificationStatus AccountLevelInfo::identity_check_status() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.identity_check_status)
+  return static_cast< ::bgs::protocol::account::v1::IdentityVerificationStatus >(identity_check_status_);
+}
+inline void AccountLevelInfo::set_identity_check_status(::bgs::protocol::account::v1::IdentityVerificationStatus value) {
+  assert(::bgs::protocol::account::v1::IdentityVerificationStatus_IsValid(value));
+  set_has_identity_check_status();
+  identity_check_status_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.identity_check_status)
+}
+
+// optional string email = 13;
+inline bool AccountLevelInfo::has_email() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void AccountLevelInfo::set_has_email() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void AccountLevelInfo::clear_has_email() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void AccountLevelInfo::clear_email() {
+  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    email_->clear();
+  }
+  clear_has_email();
+}
+inline const ::std::string& AccountLevelInfo::email() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.email)
+  return *email_;
+}
+inline void AccountLevelInfo::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.account.v1.AccountLevelInfo.email)
+}
+inline void AccountLevelInfo::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.account.v1.AccountLevelInfo.email)
+}
+inline void AccountLevelInfo::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.account.v1.AccountLevelInfo.email)
+}
+inline ::std::string* AccountLevelInfo::mutable_email() {
+  set_has_email();
+  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    email_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountLevelInfo.email)
+  return email_;
+}
+inline ::std::string* AccountLevelInfo::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 AccountLevelInfo::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.account.v1.AccountLevelInfo.email)
+}
+
+// -------------------------------------------------------------------
+
+// PrivacyInfo
+
+// optional bool is_using_rid = 3;
+inline bool PrivacyInfo::has_is_using_rid() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void PrivacyInfo::set_has_is_using_rid() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void PrivacyInfo::clear_has_is_using_rid() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void PrivacyInfo::clear_is_using_rid() {
+  is_using_rid_ = false;
+  clear_has_is_using_rid();
+}
+inline bool PrivacyInfo::is_using_rid() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.PrivacyInfo.is_using_rid)
+  return is_using_rid_;
+}
+inline void PrivacyInfo::set_is_using_rid(bool value) {
+  set_has_is_using_rid();
+  is_using_rid_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.PrivacyInfo.is_using_rid)
+}
+
+// optional bool is_real_id_visible_for_view_friends = 4;
+inline bool PrivacyInfo::has_is_real_id_visible_for_view_friends() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void PrivacyInfo::set_has_is_real_id_visible_for_view_friends() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void PrivacyInfo::clear_has_is_real_id_visible_for_view_friends() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void PrivacyInfo::clear_is_real_id_visible_for_view_friends() {
+  is_real_id_visible_for_view_friends_ = false;
+  clear_has_is_real_id_visible_for_view_friends();
+}
+inline bool PrivacyInfo::is_real_id_visible_for_view_friends() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.PrivacyInfo.is_real_id_visible_for_view_friends)
+  return is_real_id_visible_for_view_friends_;
+}
+inline void PrivacyInfo::set_is_real_id_visible_for_view_friends(bool value) {
+  set_has_is_real_id_visible_for_view_friends();
+  is_real_id_visible_for_view_friends_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.PrivacyInfo.is_real_id_visible_for_view_friends)
+}
+
+// optional bool is_hidden_from_friend_finder = 5;
+inline bool PrivacyInfo::has_is_hidden_from_friend_finder() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void PrivacyInfo::set_has_is_hidden_from_friend_finder() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void PrivacyInfo::clear_has_is_hidden_from_friend_finder() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void PrivacyInfo::clear_is_hidden_from_friend_finder() {
+  is_hidden_from_friend_finder_ = false;
+  clear_has_is_hidden_from_friend_finder();
+}
+inline bool PrivacyInfo::is_hidden_from_friend_finder() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.PrivacyInfo.is_hidden_from_friend_finder)
+  return is_hidden_from_friend_finder_;
+}
+inline void PrivacyInfo::set_is_hidden_from_friend_finder(bool value) {
+  set_has_is_hidden_from_friend_finder();
+  is_hidden_from_friend_finder_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.PrivacyInfo.is_hidden_from_friend_finder)
+}
+
+// optional .bgs.protocol.account.v1.PrivacyInfo.GameInfoPrivacy game_info_privacy = 6 [default = PRIVACY_FRIENDS];
+inline bool PrivacyInfo::has_game_info_privacy() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void PrivacyInfo::set_has_game_info_privacy() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void PrivacyInfo::clear_has_game_info_privacy() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void PrivacyInfo::clear_game_info_privacy() {
+  game_info_privacy_ = 1;
+  clear_has_game_info_privacy();
+}
+inline ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy PrivacyInfo::game_info_privacy() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.PrivacyInfo.game_info_privacy)
+  return static_cast< ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy >(game_info_privacy_);
+}
+inline void PrivacyInfo::set_game_info_privacy(::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy value) {
+  assert(::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy_IsValid(value));
+  set_has_game_info_privacy();
+  game_info_privacy_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.PrivacyInfo.game_info_privacy)
+}
+
+// -------------------------------------------------------------------
+
+// ParentalControlInfo
+
+// optional string timezone = 3;
+inline bool ParentalControlInfo::has_timezone() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ParentalControlInfo::set_has_timezone() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ParentalControlInfo::clear_has_timezone() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ParentalControlInfo::clear_timezone() {
+  if (timezone_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    timezone_->clear();
+  }
+  clear_has_timezone();
+}
+inline const ::std::string& ParentalControlInfo::timezone() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ParentalControlInfo.timezone)
+  return *timezone_;
+}
+inline void ParentalControlInfo::set_timezone(const ::std::string& value) {
+  set_has_timezone();
+  if (timezone_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    timezone_ = new ::std::string;
+  }
+  timezone_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ParentalControlInfo.timezone)
+}
+inline void ParentalControlInfo::set_timezone(const char* value) {
+  set_has_timezone();
+  if (timezone_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    timezone_ = new ::std::string;
+  }
+  timezone_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.ParentalControlInfo.timezone)
+}
+inline void ParentalControlInfo::set_timezone(const char* value, size_t size) {
+  set_has_timezone();
+  if (timezone_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    timezone_ = new ::std::string;
+  }
+  timezone_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.ParentalControlInfo.timezone)
+}
+inline ::std::string* ParentalControlInfo::mutable_timezone() {
+  set_has_timezone();
+  if (timezone_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    timezone_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.ParentalControlInfo.timezone)
+  return timezone_;
+}
+inline ::std::string* ParentalControlInfo::release_timezone() {
+  clear_has_timezone();
+  if (timezone_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = timezone_;
+    timezone_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ParentalControlInfo::set_allocated_timezone(::std::string* timezone) {
+  if (timezone_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete timezone_;
+  }
+  if (timezone) {
+    set_has_timezone();
+    timezone_ = timezone;
+  } else {
+    clear_has_timezone();
+    timezone_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.ParentalControlInfo.timezone)
+}
+
+// optional uint32 minutes_per_day = 4;
+inline bool ParentalControlInfo::has_minutes_per_day() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ParentalControlInfo::set_has_minutes_per_day() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ParentalControlInfo::clear_has_minutes_per_day() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ParentalControlInfo::clear_minutes_per_day() {
+  minutes_per_day_ = 0u;
+  clear_has_minutes_per_day();
+}
+inline ::google::protobuf::uint32 ParentalControlInfo::minutes_per_day() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ParentalControlInfo.minutes_per_day)
+  return minutes_per_day_;
+}
+inline void ParentalControlInfo::set_minutes_per_day(::google::protobuf::uint32 value) {
+  set_has_minutes_per_day();
+  minutes_per_day_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ParentalControlInfo.minutes_per_day)
+}
+
+// optional uint32 minutes_per_week = 5;
+inline bool ParentalControlInfo::has_minutes_per_week() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ParentalControlInfo::set_has_minutes_per_week() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ParentalControlInfo::clear_has_minutes_per_week() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ParentalControlInfo::clear_minutes_per_week() {
+  minutes_per_week_ = 0u;
+  clear_has_minutes_per_week();
+}
+inline ::google::protobuf::uint32 ParentalControlInfo::minutes_per_week() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ParentalControlInfo.minutes_per_week)
+  return minutes_per_week_;
+}
+inline void ParentalControlInfo::set_minutes_per_week(::google::protobuf::uint32 value) {
+  set_has_minutes_per_week();
+  minutes_per_week_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ParentalControlInfo.minutes_per_week)
+}
+
+// optional bool can_receive_voice = 6;
+inline bool ParentalControlInfo::has_can_receive_voice() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ParentalControlInfo::set_has_can_receive_voice() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ParentalControlInfo::clear_has_can_receive_voice() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ParentalControlInfo::clear_can_receive_voice() {
+  can_receive_voice_ = false;
+  clear_has_can_receive_voice();
+}
+inline bool ParentalControlInfo::can_receive_voice() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ParentalControlInfo.can_receive_voice)
+  return can_receive_voice_;
+}
+inline void ParentalControlInfo::set_can_receive_voice(bool value) {
+  set_has_can_receive_voice();
+  can_receive_voice_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ParentalControlInfo.can_receive_voice)
+}
+
+// optional bool can_send_voice = 7;
+inline bool ParentalControlInfo::has_can_send_voice() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ParentalControlInfo::set_has_can_send_voice() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ParentalControlInfo::clear_has_can_send_voice() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ParentalControlInfo::clear_can_send_voice() {
+  can_send_voice_ = false;
+  clear_has_can_send_voice();
+}
+inline bool ParentalControlInfo::can_send_voice() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ParentalControlInfo.can_send_voice)
+  return can_send_voice_;
+}
+inline void ParentalControlInfo::set_can_send_voice(bool value) {
+  set_has_can_send_voice();
+  can_send_voice_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ParentalControlInfo.can_send_voice)
+}
+
+// repeated bool play_schedule = 8;
+inline int ParentalControlInfo::play_schedule_size() const {
+  return play_schedule_.size();
+}
+inline void ParentalControlInfo::clear_play_schedule() {
+  play_schedule_.Clear();
+}
+inline bool ParentalControlInfo::play_schedule(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ParentalControlInfo.play_schedule)
+  return play_schedule_.Get(index);
+}
+inline void ParentalControlInfo::set_play_schedule(int index, bool value) {
+  play_schedule_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ParentalControlInfo.play_schedule)
+}
+inline void ParentalControlInfo::add_play_schedule(bool value) {
+  play_schedule_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.ParentalControlInfo.play_schedule)
+}
+inline const ::google::protobuf::RepeatedField< bool >&
+ParentalControlInfo::play_schedule() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.ParentalControlInfo.play_schedule)
+  return play_schedule_;
+}
+inline ::google::protobuf::RepeatedField< bool >*
+ParentalControlInfo::mutable_play_schedule() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.ParentalControlInfo.play_schedule)
+  return &play_schedule_;
+}
+
+// -------------------------------------------------------------------
+
+// GameLevelInfo
+
+// optional bool is_trial = 4;
+inline bool GameLevelInfo::has_is_trial() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameLevelInfo::set_has_is_trial() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameLevelInfo::clear_has_is_trial() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameLevelInfo::clear_is_trial() {
+  is_trial_ = false;
+  clear_has_is_trial();
+}
+inline bool GameLevelInfo::is_trial() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.is_trial)
+  return is_trial_;
+}
+inline void GameLevelInfo::set_is_trial(bool value) {
+  set_has_is_trial();
+  is_trial_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameLevelInfo.is_trial)
+}
+
+// optional bool is_lifetime = 5;
+inline bool GameLevelInfo::has_is_lifetime() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameLevelInfo::set_has_is_lifetime() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameLevelInfo::clear_has_is_lifetime() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameLevelInfo::clear_is_lifetime() {
+  is_lifetime_ = false;
+  clear_has_is_lifetime();
+}
+inline bool GameLevelInfo::is_lifetime() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.is_lifetime)
+  return is_lifetime_;
+}
+inline void GameLevelInfo::set_is_lifetime(bool value) {
+  set_has_is_lifetime();
+  is_lifetime_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameLevelInfo.is_lifetime)
+}
+
+// optional bool is_restricted = 6;
+inline bool GameLevelInfo::has_is_restricted() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GameLevelInfo::set_has_is_restricted() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GameLevelInfo::clear_has_is_restricted() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GameLevelInfo::clear_is_restricted() {
+  is_restricted_ = false;
+  clear_has_is_restricted();
+}
+inline bool GameLevelInfo::is_restricted() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.is_restricted)
+  return is_restricted_;
+}
+inline void GameLevelInfo::set_is_restricted(bool value) {
+  set_has_is_restricted();
+  is_restricted_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameLevelInfo.is_restricted)
+}
+
+// optional bool is_beta = 7;
+inline bool GameLevelInfo::has_is_beta() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GameLevelInfo::set_has_is_beta() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GameLevelInfo::clear_has_is_beta() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GameLevelInfo::clear_is_beta() {
+  is_beta_ = false;
+  clear_has_is_beta();
+}
+inline bool GameLevelInfo::is_beta() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.is_beta)
+  return is_beta_;
+}
+inline void GameLevelInfo::set_is_beta(bool value) {
+  set_has_is_beta();
+  is_beta_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameLevelInfo.is_beta)
+}
+
+// optional string name = 8;
+inline bool GameLevelInfo::has_name() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void GameLevelInfo::set_has_name() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void GameLevelInfo::clear_has_name() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void GameLevelInfo::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& GameLevelInfo::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.name)
+  return *name_;
+}
+inline void GameLevelInfo::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameLevelInfo.name)
+}
+inline void GameLevelInfo::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GameLevelInfo.name)
+}
+inline void GameLevelInfo::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GameLevelInfo.name)
+}
+inline ::std::string* GameLevelInfo::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameLevelInfo.name)
+  return name_;
+}
+inline ::std::string* GameLevelInfo::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void GameLevelInfo::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameLevelInfo.name)
+}
+
+// optional fixed32 program = 9;
+inline bool GameLevelInfo::has_program() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void GameLevelInfo::set_has_program() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void GameLevelInfo::clear_has_program() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void GameLevelInfo::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 GameLevelInfo::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.program)
+  return program_;
+}
+inline void GameLevelInfo::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameLevelInfo.program)
+}
+
+// repeated .bgs.protocol.account.v1.AccountLicense licenses = 10;
+inline int GameLevelInfo::licenses_size() const {
+  return licenses_.size();
+}
+inline void GameLevelInfo::clear_licenses() {
+  licenses_.Clear();
+}
+inline const ::bgs::protocol::account::v1::AccountLicense& GameLevelInfo::licenses(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.licenses)
+  return licenses_.Get(index);
+}
+inline ::bgs::protocol::account::v1::AccountLicense* GameLevelInfo::mutable_licenses(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameLevelInfo.licenses)
+  return licenses_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::AccountLicense* GameLevelInfo::add_licenses() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GameLevelInfo.licenses)
+  return licenses_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >&
+GameLevelInfo::licenses() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GameLevelInfo.licenses)
+  return licenses_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >*
+GameLevelInfo::mutable_licenses() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GameLevelInfo.licenses)
+  return &licenses_;
+}
+
+// optional uint32 realm_permissions = 11;
+inline bool GameLevelInfo::has_realm_permissions() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void GameLevelInfo::set_has_realm_permissions() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void GameLevelInfo::clear_has_realm_permissions() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void GameLevelInfo::clear_realm_permissions() {
+  realm_permissions_ = 0u;
+  clear_has_realm_permissions();
+}
+inline ::google::protobuf::uint32 GameLevelInfo::realm_permissions() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.realm_permissions)
+  return realm_permissions_;
+}
+inline void GameLevelInfo::set_realm_permissions(::google::protobuf::uint32 value) {
+  set_has_realm_permissions();
+  realm_permissions_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameLevelInfo.realm_permissions)
+}
+
+// -------------------------------------------------------------------
+
+// GameTimeInfo
+
+// optional bool is_unlimited_play_time = 3;
+inline bool GameTimeInfo::has_is_unlimited_play_time() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameTimeInfo::set_has_is_unlimited_play_time() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameTimeInfo::clear_has_is_unlimited_play_time() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameTimeInfo::clear_is_unlimited_play_time() {
+  is_unlimited_play_time_ = false;
+  clear_has_is_unlimited_play_time();
+}
+inline bool GameTimeInfo::is_unlimited_play_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameTimeInfo.is_unlimited_play_time)
+  return is_unlimited_play_time_;
+}
+inline void GameTimeInfo::set_is_unlimited_play_time(bool value) {
+  set_has_is_unlimited_play_time();
+  is_unlimited_play_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeInfo.is_unlimited_play_time)
+}
+
+// optional uint64 play_time_expires = 5;
+inline bool GameTimeInfo::has_play_time_expires() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameTimeInfo::set_has_play_time_expires() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameTimeInfo::clear_has_play_time_expires() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameTimeInfo::clear_play_time_expires() {
+  play_time_expires_ = GOOGLE_ULONGLONG(0);
+  clear_has_play_time_expires();
+}
+inline ::google::protobuf::uint64 GameTimeInfo::play_time_expires() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameTimeInfo.play_time_expires)
+  return play_time_expires_;
+}
+inline void GameTimeInfo::set_play_time_expires(::google::protobuf::uint64 value) {
+  set_has_play_time_expires();
+  play_time_expires_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeInfo.play_time_expires)
+}
+
+// optional bool is_subscription = 6;
+inline bool GameTimeInfo::has_is_subscription() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GameTimeInfo::set_has_is_subscription() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GameTimeInfo::clear_has_is_subscription() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GameTimeInfo::clear_is_subscription() {
+  is_subscription_ = false;
+  clear_has_is_subscription();
+}
+inline bool GameTimeInfo::is_subscription() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameTimeInfo.is_subscription)
+  return is_subscription_;
+}
+inline void GameTimeInfo::set_is_subscription(bool value) {
+  set_has_is_subscription();
+  is_subscription_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeInfo.is_subscription)
+}
+
+// optional bool is_recurring_subscription = 7;
+inline bool GameTimeInfo::has_is_recurring_subscription() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GameTimeInfo::set_has_is_recurring_subscription() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GameTimeInfo::clear_has_is_recurring_subscription() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GameTimeInfo::clear_is_recurring_subscription() {
+  is_recurring_subscription_ = false;
+  clear_has_is_recurring_subscription();
+}
+inline bool GameTimeInfo::is_recurring_subscription() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameTimeInfo.is_recurring_subscription)
+  return is_recurring_subscription_;
+}
+inline void GameTimeInfo::set_is_recurring_subscription(bool value) {
+  set_has_is_recurring_subscription();
+  is_recurring_subscription_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeInfo.is_recurring_subscription)
+}
+
+// -------------------------------------------------------------------
+
+// GameTimeRemainingInfo
+
+// optional uint32 minutes_remaining = 1;
+inline bool GameTimeRemainingInfo::has_minutes_remaining() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameTimeRemainingInfo::set_has_minutes_remaining() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameTimeRemainingInfo::clear_has_minutes_remaining() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameTimeRemainingInfo::clear_minutes_remaining() {
+  minutes_remaining_ = 0u;
+  clear_has_minutes_remaining();
+}
+inline ::google::protobuf::uint32 GameTimeRemainingInfo::minutes_remaining() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameTimeRemainingInfo.minutes_remaining)
+  return minutes_remaining_;
+}
+inline void GameTimeRemainingInfo::set_minutes_remaining(::google::protobuf::uint32 value) {
+  set_has_minutes_remaining();
+  minutes_remaining_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeRemainingInfo.minutes_remaining)
+}
+
+// optional uint32 parental_daily_minutes_remaining = 2;
+inline bool GameTimeRemainingInfo::has_parental_daily_minutes_remaining() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameTimeRemainingInfo::set_has_parental_daily_minutes_remaining() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameTimeRemainingInfo::clear_has_parental_daily_minutes_remaining() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameTimeRemainingInfo::clear_parental_daily_minutes_remaining() {
+  parental_daily_minutes_remaining_ = 0u;
+  clear_has_parental_daily_minutes_remaining();
+}
+inline ::google::protobuf::uint32 GameTimeRemainingInfo::parental_daily_minutes_remaining() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameTimeRemainingInfo.parental_daily_minutes_remaining)
+  return parental_daily_minutes_remaining_;
+}
+inline void GameTimeRemainingInfo::set_parental_daily_minutes_remaining(::google::protobuf::uint32 value) {
+  set_has_parental_daily_minutes_remaining();
+  parental_daily_minutes_remaining_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeRemainingInfo.parental_daily_minutes_remaining)
+}
+
+// optional uint32 parental_weekly_minutes_remaining = 3;
+inline bool GameTimeRemainingInfo::has_parental_weekly_minutes_remaining() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GameTimeRemainingInfo::set_has_parental_weekly_minutes_remaining() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GameTimeRemainingInfo::clear_has_parental_weekly_minutes_remaining() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GameTimeRemainingInfo::clear_parental_weekly_minutes_remaining() {
+  parental_weekly_minutes_remaining_ = 0u;
+  clear_has_parental_weekly_minutes_remaining();
+}
+inline ::google::protobuf::uint32 GameTimeRemainingInfo::parental_weekly_minutes_remaining() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameTimeRemainingInfo.parental_weekly_minutes_remaining)
+  return parental_weekly_minutes_remaining_;
+}
+inline void GameTimeRemainingInfo::set_parental_weekly_minutes_remaining(::google::protobuf::uint32 value) {
+  set_has_parental_weekly_minutes_remaining();
+  parental_weekly_minutes_remaining_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeRemainingInfo.parental_weekly_minutes_remaining)
+}
+
+// optional uint32 seconds_remaining_until_kick = 4;
+inline bool GameTimeRemainingInfo::has_seconds_remaining_until_kick() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GameTimeRemainingInfo::set_has_seconds_remaining_until_kick() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GameTimeRemainingInfo::clear_has_seconds_remaining_until_kick() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GameTimeRemainingInfo::clear_seconds_remaining_until_kick() {
+  seconds_remaining_until_kick_ = 0u;
+  clear_has_seconds_remaining_until_kick();
+}
+inline ::google::protobuf::uint32 GameTimeRemainingInfo::seconds_remaining_until_kick() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameTimeRemainingInfo.seconds_remaining_until_kick)
+  return seconds_remaining_until_kick_;
+}
+inline void GameTimeRemainingInfo::set_seconds_remaining_until_kick(::google::protobuf::uint32 value) {
+  set_has_seconds_remaining_until_kick();
+  seconds_remaining_until_kick_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameTimeRemainingInfo.seconds_remaining_until_kick)
+}
+
+// -------------------------------------------------------------------
+
+// GameStatus
+
+// optional bool is_suspended = 4;
+inline bool GameStatus::has_is_suspended() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameStatus::set_has_is_suspended() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameStatus::clear_has_is_suspended() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameStatus::clear_is_suspended() {
+  is_suspended_ = false;
+  clear_has_is_suspended();
+}
+inline bool GameStatus::is_suspended() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameStatus.is_suspended)
+  return is_suspended_;
+}
+inline void GameStatus::set_is_suspended(bool value) {
+  set_has_is_suspended();
+  is_suspended_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameStatus.is_suspended)
+}
+
+// optional bool is_banned = 5;
+inline bool GameStatus::has_is_banned() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameStatus::set_has_is_banned() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameStatus::clear_has_is_banned() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameStatus::clear_is_banned() {
+  is_banned_ = false;
+  clear_has_is_banned();
+}
+inline bool GameStatus::is_banned() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameStatus.is_banned)
+  return is_banned_;
+}
+inline void GameStatus::set_is_banned(bool value) {
+  set_has_is_banned();
+  is_banned_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameStatus.is_banned)
+}
+
+// optional uint64 suspension_expires = 6;
+inline bool GameStatus::has_suspension_expires() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GameStatus::set_has_suspension_expires() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GameStatus::clear_has_suspension_expires() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GameStatus::clear_suspension_expires() {
+  suspension_expires_ = GOOGLE_ULONGLONG(0);
+  clear_has_suspension_expires();
+}
+inline ::google::protobuf::uint64 GameStatus::suspension_expires() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameStatus.suspension_expires)
+  return suspension_expires_;
+}
+inline void GameStatus::set_suspension_expires(::google::protobuf::uint64 value) {
+  set_has_suspension_expires();
+  suspension_expires_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameStatus.suspension_expires)
+}
+
+// optional fixed32 program = 7;
+inline bool GameStatus::has_program() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GameStatus::set_has_program() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GameStatus::clear_has_program() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GameStatus::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 GameStatus::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameStatus.program)
+  return program_;
+}
+inline void GameStatus::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameStatus.program)
+}
+
+// optional bool is_locked = 8;
+inline bool GameStatus::has_is_locked() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void GameStatus::set_has_is_locked() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void GameStatus::clear_has_is_locked() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void GameStatus::clear_is_locked() {
+  is_locked_ = false;
+  clear_has_is_locked();
+}
+inline bool GameStatus::is_locked() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameStatus.is_locked)
+  return is_locked_;
+}
+inline void GameStatus::set_is_locked(bool value) {
+  set_has_is_locked();
+  is_locked_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameStatus.is_locked)
+}
+
+// optional bool is_bam_unlockable = 9;
+inline bool GameStatus::has_is_bam_unlockable() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void GameStatus::set_has_is_bam_unlockable() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void GameStatus::clear_has_is_bam_unlockable() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void GameStatus::clear_is_bam_unlockable() {
+  is_bam_unlockable_ = false;
+  clear_has_is_bam_unlockable();
+}
+inline bool GameStatus::is_bam_unlockable() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameStatus.is_bam_unlockable)
+  return is_bam_unlockable_;
+}
+inline void GameStatus::set_is_bam_unlockable(bool value) {
+  set_has_is_bam_unlockable();
+  is_bam_unlockable_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameStatus.is_bam_unlockable)
+}
+
+// -------------------------------------------------------------------
+
+// RAFInfo
+
+// optional bytes raf_info = 1;
+inline bool RAFInfo::has_raf_info() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RAFInfo::set_has_raf_info() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RAFInfo::clear_has_raf_info() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RAFInfo::clear_raf_info() {
+  if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raf_info_->clear();
+  }
+  clear_has_raf_info();
+}
+inline const ::std::string& RAFInfo::raf_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.RAFInfo.raf_info)
+  return *raf_info_;
+}
+inline void RAFInfo::set_raf_info(const ::std::string& value) {
+  set_has_raf_info();
+  if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raf_info_ = new ::std::string;
+  }
+  raf_info_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.RAFInfo.raf_info)
+}
+inline void RAFInfo::set_raf_info(const char* value) {
+  set_has_raf_info();
+  if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raf_info_ = new ::std::string;
+  }
+  raf_info_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.RAFInfo.raf_info)
+}
+inline void RAFInfo::set_raf_info(const void* value, size_t size) {
+  set_has_raf_info();
+  if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raf_info_ = new ::std::string;
+  }
+  raf_info_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.RAFInfo.raf_info)
+}
+inline ::std::string* RAFInfo::mutable_raf_info() {
+  set_has_raf_info();
+  if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    raf_info_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.RAFInfo.raf_info)
+  return raf_info_;
+}
+inline ::std::string* RAFInfo::release_raf_info() {
+  clear_has_raf_info();
+  if (raf_info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = raf_info_;
+    raf_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void RAFInfo::set_allocated_raf_info(::std::string* raf_info) {
+  if (raf_info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete raf_info_;
+  }
+  if (raf_info) {
+    set_has_raf_info();
+    raf_info_ = raf_info;
+  } else {
+    clear_has_raf_info();
+    raf_info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.RAFInfo.raf_info)
+}
+
+// -------------------------------------------------------------------
+
+// GameSessionInfo
+
+// optional uint32 start_time = 3 [deprecated = true];
+inline bool GameSessionInfo::has_start_time() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameSessionInfo::set_has_start_time() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameSessionInfo::clear_has_start_time() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameSessionInfo::clear_start_time() {
+  start_time_ = 0u;
+  clear_has_start_time();
+}
+inline ::google::protobuf::uint32 GameSessionInfo::start_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionInfo.start_time)
+  return start_time_;
+}
+inline void GameSessionInfo::set_start_time(::google::protobuf::uint32 value) {
+  set_has_start_time();
+  start_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionInfo.start_time)
+}
+
+// optional .bgs.protocol.account.v1.GameSessionLocation location = 4;
+inline bool GameSessionInfo::has_location() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameSessionInfo::set_has_location() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameSessionInfo::clear_has_location() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameSessionInfo::clear_location() {
+  if (location_ != NULL) location_->::bgs::protocol::account::v1::GameSessionLocation::Clear();
+  clear_has_location();
+}
+inline const ::bgs::protocol::account::v1::GameSessionLocation& GameSessionInfo::location() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionInfo.location)
+  return location_ != NULL ? *location_ : *default_instance_->location_;
+}
+inline ::bgs::protocol::account::v1::GameSessionLocation* GameSessionInfo::mutable_location() {
+  set_has_location();
+  if (location_ == NULL) location_ = new ::bgs::protocol::account::v1::GameSessionLocation;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameSessionInfo.location)
+  return location_;
+}
+inline ::bgs::protocol::account::v1::GameSessionLocation* GameSessionInfo::release_location() {
+  clear_has_location();
+  ::bgs::protocol::account::v1::GameSessionLocation* temp = location_;
+  location_ = NULL;
+  return temp;
+}
+inline void GameSessionInfo::set_allocated_location(::bgs::protocol::account::v1::GameSessionLocation* location) {
+  delete location_;
+  location_ = location;
+  if (location) {
+    set_has_location();
+  } else {
+    clear_has_location();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameSessionInfo.location)
+}
+
+// optional bool has_benefactor = 5;
+inline bool GameSessionInfo::has_has_benefactor() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GameSessionInfo::set_has_has_benefactor() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GameSessionInfo::clear_has_has_benefactor() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GameSessionInfo::clear_has_benefactor() {
+  has_benefactor_ = false;
+  clear_has_has_benefactor();
+}
+inline bool GameSessionInfo::has_benefactor() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionInfo.has_benefactor)
+  return has_benefactor_;
+}
+inline void GameSessionInfo::set_has_benefactor(bool value) {
+  set_has_has_benefactor();
+  has_benefactor_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionInfo.has_benefactor)
+}
+
+// optional bool is_using_igr = 6;
+inline bool GameSessionInfo::has_is_using_igr() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GameSessionInfo::set_has_is_using_igr() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GameSessionInfo::clear_has_is_using_igr() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GameSessionInfo::clear_is_using_igr() {
+  is_using_igr_ = false;
+  clear_has_is_using_igr();
+}
+inline bool GameSessionInfo::is_using_igr() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionInfo.is_using_igr)
+  return is_using_igr_;
+}
+inline void GameSessionInfo::set_is_using_igr(bool value) {
+  set_has_is_using_igr();
+  is_using_igr_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionInfo.is_using_igr)
+}
+
+// optional bool parental_controls_active = 7;
+inline bool GameSessionInfo::has_parental_controls_active() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void GameSessionInfo::set_has_parental_controls_active() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void GameSessionInfo::clear_has_parental_controls_active() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void GameSessionInfo::clear_parental_controls_active() {
+  parental_controls_active_ = false;
+  clear_has_parental_controls_active();
+}
+inline bool GameSessionInfo::parental_controls_active() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionInfo.parental_controls_active)
+  return parental_controls_active_;
+}
+inline void GameSessionInfo::set_parental_controls_active(bool value) {
+  set_has_parental_controls_active();
+  parental_controls_active_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionInfo.parental_controls_active)
+}
+
+// optional uint64 start_time_sec = 8;
+inline bool GameSessionInfo::has_start_time_sec() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void GameSessionInfo::set_has_start_time_sec() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void GameSessionInfo::clear_has_start_time_sec() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void GameSessionInfo::clear_start_time_sec() {
+  start_time_sec_ = GOOGLE_ULONGLONG(0);
+  clear_has_start_time_sec();
+}
+inline ::google::protobuf::uint64 GameSessionInfo::start_time_sec() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionInfo.start_time_sec)
+  return start_time_sec_;
+}
+inline void GameSessionInfo::set_start_time_sec(::google::protobuf::uint64 value) {
+  set_has_start_time_sec();
+  start_time_sec_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionInfo.start_time_sec)
+}
+
+// -------------------------------------------------------------------
+
+// GameSessionUpdateInfo
+
+// optional .bgs.protocol.account.v1.CAIS cais = 8;
+inline bool GameSessionUpdateInfo::has_cais() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameSessionUpdateInfo::set_has_cais() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameSessionUpdateInfo::clear_has_cais() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameSessionUpdateInfo::clear_cais() {
+  if (cais_ != NULL) cais_->::bgs::protocol::account::v1::CAIS::Clear();
+  clear_has_cais();
+}
+inline const ::bgs::protocol::account::v1::CAIS& GameSessionUpdateInfo::cais() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionUpdateInfo.cais)
+  return cais_ != NULL ? *cais_ : *default_instance_->cais_;
+}
+inline ::bgs::protocol::account::v1::CAIS* GameSessionUpdateInfo::mutable_cais() {
+  set_has_cais();
+  if (cais_ == NULL) cais_ = new ::bgs::protocol::account::v1::CAIS;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameSessionUpdateInfo.cais)
+  return cais_;
+}
+inline ::bgs::protocol::account::v1::CAIS* GameSessionUpdateInfo::release_cais() {
+  clear_has_cais();
+  ::bgs::protocol::account::v1::CAIS* temp = cais_;
+  cais_ = NULL;
+  return temp;
+}
+inline void GameSessionUpdateInfo::set_allocated_cais(::bgs::protocol::account::v1::CAIS* cais) {
+  delete cais_;
+  cais_ = cais;
+  if (cais) {
+    set_has_cais();
+  } else {
+    clear_has_cais();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameSessionUpdateInfo.cais)
+}
+
+// -------------------------------------------------------------------
+
+// GameSessionLocation
+
+// optional string ip_address = 1;
+inline bool GameSessionLocation::has_ip_address() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameSessionLocation::set_has_ip_address() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameSessionLocation::clear_has_ip_address() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameSessionLocation::clear_ip_address() {
+  if (ip_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ip_address_->clear();
+  }
+  clear_has_ip_address();
+}
+inline const ::std::string& GameSessionLocation::ip_address() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionLocation.ip_address)
+  return *ip_address_;
+}
+inline void GameSessionLocation::set_ip_address(const ::std::string& value) {
+  set_has_ip_address();
+  if (ip_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ip_address_ = new ::std::string;
+  }
+  ip_address_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionLocation.ip_address)
+}
+inline void GameSessionLocation::set_ip_address(const char* value) {
+  set_has_ip_address();
+  if (ip_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ip_address_ = new ::std::string;
+  }
+  ip_address_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GameSessionLocation.ip_address)
+}
+inline void GameSessionLocation::set_ip_address(const char* value, size_t size) {
+  set_has_ip_address();
+  if (ip_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ip_address_ = new ::std::string;
+  }
+  ip_address_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GameSessionLocation.ip_address)
+}
+inline ::std::string* GameSessionLocation::mutable_ip_address() {
+  set_has_ip_address();
+  if (ip_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    ip_address_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameSessionLocation.ip_address)
+  return ip_address_;
+}
+inline ::std::string* GameSessionLocation::release_ip_address() {
+  clear_has_ip_address();
+  if (ip_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = ip_address_;
+    ip_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void GameSessionLocation::set_allocated_ip_address(::std::string* ip_address) {
+  if (ip_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete ip_address_;
+  }
+  if (ip_address) {
+    set_has_ip_address();
+    ip_address_ = ip_address;
+  } else {
+    clear_has_ip_address();
+    ip_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameSessionLocation.ip_address)
+}
+
+// optional uint32 country = 2;
+inline bool GameSessionLocation::has_country() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameSessionLocation::set_has_country() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameSessionLocation::clear_has_country() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameSessionLocation::clear_country() {
+  country_ = 0u;
+  clear_has_country();
+}
+inline ::google::protobuf::uint32 GameSessionLocation::country() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionLocation.country)
+  return country_;
+}
+inline void GameSessionLocation::set_country(::google::protobuf::uint32 value) {
+  set_has_country();
+  country_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionLocation.country)
+}
+
+// optional string city = 3;
+inline bool GameSessionLocation::has_city() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GameSessionLocation::set_has_city() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GameSessionLocation::clear_has_city() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GameSessionLocation::clear_city() {
+  if (city_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    city_->clear();
+  }
+  clear_has_city();
+}
+inline const ::std::string& GameSessionLocation::city() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionLocation.city)
+  return *city_;
+}
+inline void GameSessionLocation::set_city(const ::std::string& value) {
+  set_has_city();
+  if (city_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    city_ = new ::std::string;
+  }
+  city_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionLocation.city)
+}
+inline void GameSessionLocation::set_city(const char* value) {
+  set_has_city();
+  if (city_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    city_ = new ::std::string;
+  }
+  city_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GameSessionLocation.city)
+}
+inline void GameSessionLocation::set_city(const char* value, size_t size) {
+  set_has_city();
+  if (city_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    city_ = new ::std::string;
+  }
+  city_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GameSessionLocation.city)
+}
+inline ::std::string* GameSessionLocation::mutable_city() {
+  set_has_city();
+  if (city_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    city_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameSessionLocation.city)
+  return city_;
+}
+inline ::std::string* GameSessionLocation::release_city() {
+  clear_has_city();
+  if (city_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = city_;
+    city_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void GameSessionLocation::set_allocated_city(::std::string* city) {
+  if (city_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete city_;
+  }
+  if (city) {
+    set_has_city();
+    city_ = city;
+  } else {
+    clear_has_city();
+    city_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameSessionLocation.city)
+}
+
+// -------------------------------------------------------------------
+
+// CAIS
+
+// optional uint32 played_minutes = 1;
+inline bool CAIS::has_played_minutes() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CAIS::set_has_played_minutes() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CAIS::clear_has_played_minutes() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CAIS::clear_played_minutes() {
+  played_minutes_ = 0u;
+  clear_has_played_minutes();
+}
+inline ::google::protobuf::uint32 CAIS::played_minutes() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CAIS.played_minutes)
+  return played_minutes_;
+}
+inline void CAIS::set_played_minutes(::google::protobuf::uint32 value) {
+  set_has_played_minutes();
+  played_minutes_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CAIS.played_minutes)
+}
+
+// optional uint32 rested_minutes = 2;
+inline bool CAIS::has_rested_minutes() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void CAIS::set_has_rested_minutes() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void CAIS::clear_has_rested_minutes() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void CAIS::clear_rested_minutes() {
+  rested_minutes_ = 0u;
+  clear_has_rested_minutes();
+}
+inline ::google::protobuf::uint32 CAIS::rested_minutes() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CAIS.rested_minutes)
+  return rested_minutes_;
+}
+inline void CAIS::set_rested_minutes(::google::protobuf::uint32 value) {
+  set_has_rested_minutes();
+  rested_minutes_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CAIS.rested_minutes)
+}
+
+// optional uint64 last_heard_time = 3;
+inline bool CAIS::has_last_heard_time() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void CAIS::set_has_last_heard_time() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void CAIS::clear_has_last_heard_time() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void CAIS::clear_last_heard_time() {
+  last_heard_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_last_heard_time();
+}
+inline ::google::protobuf::uint64 CAIS::last_heard_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.CAIS.last_heard_time)
+  return last_heard_time_;
+}
+inline void CAIS::set_last_heard_time(::google::protobuf::uint64 value) {
+  set_has_last_heard_time();
+  last_heard_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.CAIS.last_heard_time)
+}
+
+// -------------------------------------------------------------------
+
+// GameAccountList
+
+// optional uint32 region = 3;
+inline bool GameAccountList::has_region() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameAccountList::set_has_region() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameAccountList::clear_has_region() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameAccountList::clear_region() {
+  region_ = 0u;
+  clear_has_region();
+}
+inline ::google::protobuf::uint32 GameAccountList::region() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountList.region)
+  return region_;
+}
+inline void GameAccountList::set_region(::google::protobuf::uint32 value) {
+  set_has_region();
+  region_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountList.region)
+}
+
+// repeated .bgs.protocol.account.v1.GameAccountHandle handle = 4;
+inline int GameAccountList::handle_size() const {
+  return handle_.size();
+}
+inline void GameAccountList::clear_handle() {
+  handle_.Clear();
+}
+inline const ::bgs::protocol::account::v1::GameAccountHandle& GameAccountList::handle(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountList.handle)
+  return handle_.Get(index);
+}
+inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountList::mutable_handle(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountList.handle)
+  return handle_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountList::add_handle() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GameAccountList.handle)
+  return handle_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >&
+GameAccountList::handle() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GameAccountList.handle)
+  return handle_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountHandle >*
+GameAccountList::mutable_handle() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GameAccountList.handle)
+  return &handle_;
+}
+
+// -------------------------------------------------------------------
+
+// AccountState
+
+// optional .bgs.protocol.account.v1.AccountLevelInfo account_level_info = 1;
+inline bool AccountState::has_account_level_info() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AccountState::set_has_account_level_info() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AccountState::clear_has_account_level_info() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AccountState::clear_account_level_info() {
+  if (account_level_info_ != NULL) account_level_info_->::bgs::protocol::account::v1::AccountLevelInfo::Clear();
+  clear_has_account_level_info();
+}
+inline const ::bgs::protocol::account::v1::AccountLevelInfo& AccountState::account_level_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountState.account_level_info)
+  return account_level_info_ != NULL ? *account_level_info_ : *default_instance_->account_level_info_;
+}
+inline ::bgs::protocol::account::v1::AccountLevelInfo* AccountState::mutable_account_level_info() {
+  set_has_account_level_info();
+  if (account_level_info_ == NULL) account_level_info_ = new ::bgs::protocol::account::v1::AccountLevelInfo;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountState.account_level_info)
+  return account_level_info_;
+}
+inline ::bgs::protocol::account::v1::AccountLevelInfo* AccountState::release_account_level_info() {
+  clear_has_account_level_info();
+  ::bgs::protocol::account::v1::AccountLevelInfo* temp = account_level_info_;
+  account_level_info_ = NULL;
+  return temp;
+}
+inline void AccountState::set_allocated_account_level_info(::bgs::protocol::account::v1::AccountLevelInfo* account_level_info) {
+  delete account_level_info_;
+  account_level_info_ = account_level_info;
+  if (account_level_info) {
+    set_has_account_level_info();
+  } else {
+    clear_has_account_level_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountState.account_level_info)
+}
+
+// optional .bgs.protocol.account.v1.PrivacyInfo privacy_info = 2;
+inline bool AccountState::has_privacy_info() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AccountState::set_has_privacy_info() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AccountState::clear_has_privacy_info() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AccountState::clear_privacy_info() {
+  if (privacy_info_ != NULL) privacy_info_->::bgs::protocol::account::v1::PrivacyInfo::Clear();
+  clear_has_privacy_info();
+}
+inline const ::bgs::protocol::account::v1::PrivacyInfo& AccountState::privacy_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountState.privacy_info)
+  return privacy_info_ != NULL ? *privacy_info_ : *default_instance_->privacy_info_;
+}
+inline ::bgs::protocol::account::v1::PrivacyInfo* AccountState::mutable_privacy_info() {
+  set_has_privacy_info();
+  if (privacy_info_ == NULL) privacy_info_ = new ::bgs::protocol::account::v1::PrivacyInfo;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountState.privacy_info)
+  return privacy_info_;
+}
+inline ::bgs::protocol::account::v1::PrivacyInfo* AccountState::release_privacy_info() {
+  clear_has_privacy_info();
+  ::bgs::protocol::account::v1::PrivacyInfo* temp = privacy_info_;
+  privacy_info_ = NULL;
+  return temp;
+}
+inline void AccountState::set_allocated_privacy_info(::bgs::protocol::account::v1::PrivacyInfo* privacy_info) {
+  delete privacy_info_;
+  privacy_info_ = privacy_info;
+  if (privacy_info) {
+    set_has_privacy_info();
+  } else {
+    clear_has_privacy_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountState.privacy_info)
+}
+
+// optional .bgs.protocol.account.v1.ParentalControlInfo parental_control_info = 3;
+inline bool AccountState::has_parental_control_info() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AccountState::set_has_parental_control_info() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AccountState::clear_has_parental_control_info() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AccountState::clear_parental_control_info() {
+  if (parental_control_info_ != NULL) parental_control_info_->::bgs::protocol::account::v1::ParentalControlInfo::Clear();
+  clear_has_parental_control_info();
+}
+inline const ::bgs::protocol::account::v1::ParentalControlInfo& AccountState::parental_control_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountState.parental_control_info)
+  return parental_control_info_ != NULL ? *parental_control_info_ : *default_instance_->parental_control_info_;
+}
+inline ::bgs::protocol::account::v1::ParentalControlInfo* AccountState::mutable_parental_control_info() {
+  set_has_parental_control_info();
+  if (parental_control_info_ == NULL) parental_control_info_ = new ::bgs::protocol::account::v1::ParentalControlInfo;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountState.parental_control_info)
+  return parental_control_info_;
+}
+inline ::bgs::protocol::account::v1::ParentalControlInfo* AccountState::release_parental_control_info() {
+  clear_has_parental_control_info();
+  ::bgs::protocol::account::v1::ParentalControlInfo* temp = parental_control_info_;
+  parental_control_info_ = NULL;
+  return temp;
+}
+inline void AccountState::set_allocated_parental_control_info(::bgs::protocol::account::v1::ParentalControlInfo* parental_control_info) {
+  delete parental_control_info_;
+  parental_control_info_ = parental_control_info;
+  if (parental_control_info) {
+    set_has_parental_control_info();
+  } else {
+    clear_has_parental_control_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountState.parental_control_info)
+}
+
+// repeated .bgs.protocol.account.v1.GameLevelInfo game_level_info = 5;
+inline int AccountState::game_level_info_size() const {
+  return game_level_info_.size();
+}
+inline void AccountState::clear_game_level_info() {
+  game_level_info_.Clear();
+}
+inline const ::bgs::protocol::account::v1::GameLevelInfo& AccountState::game_level_info(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountState.game_level_info)
+  return game_level_info_.Get(index);
+}
+inline ::bgs::protocol::account::v1::GameLevelInfo* AccountState::mutable_game_level_info(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountState.game_level_info)
+  return game_level_info_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::GameLevelInfo* AccountState::add_game_level_info() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountState.game_level_info)
+  return game_level_info_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameLevelInfo >&
+AccountState::game_level_info() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountState.game_level_info)
+  return game_level_info_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameLevelInfo >*
+AccountState::mutable_game_level_info() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountState.game_level_info)
+  return &game_level_info_;
+}
+
+// repeated .bgs.protocol.account.v1.GameStatus game_status = 6;
+inline int AccountState::game_status_size() const {
+  return game_status_.size();
+}
+inline void AccountState::clear_game_status() {
+  game_status_.Clear();
+}
+inline const ::bgs::protocol::account::v1::GameStatus& AccountState::game_status(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountState.game_status)
+  return game_status_.Get(index);
+}
+inline ::bgs::protocol::account::v1::GameStatus* AccountState::mutable_game_status(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountState.game_status)
+  return game_status_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::GameStatus* AccountState::add_game_status() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountState.game_status)
+  return game_status_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameStatus >&
+AccountState::game_status() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountState.game_status)
+  return game_status_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameStatus >*
+AccountState::mutable_game_status() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountState.game_status)
+  return &game_status_;
+}
+
+// repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 7;
+inline int AccountState::game_accounts_size() const {
+  return game_accounts_.size();
+}
+inline void AccountState::clear_game_accounts() {
+  game_accounts_.Clear();
+}
+inline const ::bgs::protocol::account::v1::GameAccountList& AccountState::game_accounts(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountState.game_accounts)
+  return game_accounts_.Get(index);
+}
+inline ::bgs::protocol::account::v1::GameAccountList* AccountState::mutable_game_accounts(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountState.game_accounts)
+  return game_accounts_.Mutable(index);
+}
+inline ::bgs::protocol::account::v1::GameAccountList* AccountState::add_game_accounts() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AccountState.game_accounts)
+  return game_accounts_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >&
+AccountState::game_accounts() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AccountState.game_accounts)
+  return game_accounts_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >*
+AccountState::mutable_game_accounts() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AccountState.game_accounts)
+  return &game_accounts_;
+}
+
+// -------------------------------------------------------------------
+
+// AccountStateTagged
+
+// optional .bgs.protocol.account.v1.AccountState account_state = 1;
+inline bool AccountStateTagged::has_account_state() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AccountStateTagged::set_has_account_state() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AccountStateTagged::clear_has_account_state() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AccountStateTagged::clear_account_state() {
+  if (account_state_ != NULL) account_state_->::bgs::protocol::account::v1::AccountState::Clear();
+  clear_has_account_state();
+}
+inline const ::bgs::protocol::account::v1::AccountState& AccountStateTagged::account_state() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountStateTagged.account_state)
+  return account_state_ != NULL ? *account_state_ : *default_instance_->account_state_;
+}
+inline ::bgs::protocol::account::v1::AccountState* AccountStateTagged::mutable_account_state() {
+  set_has_account_state();
+  if (account_state_ == NULL) account_state_ = new ::bgs::protocol::account::v1::AccountState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountStateTagged.account_state)
+  return account_state_;
+}
+inline ::bgs::protocol::account::v1::AccountState* AccountStateTagged::release_account_state() {
+  clear_has_account_state();
+  ::bgs::protocol::account::v1::AccountState* temp = account_state_;
+  account_state_ = NULL;
+  return temp;
+}
+inline void AccountStateTagged::set_allocated_account_state(::bgs::protocol::account::v1::AccountState* account_state) {
+  delete account_state_;
+  account_state_ = account_state;
+  if (account_state) {
+    set_has_account_state();
+  } else {
+    clear_has_account_state();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountStateTagged.account_state)
+}
+
+// optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 2;
+inline bool AccountStateTagged::has_account_tags() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AccountStateTagged::set_has_account_tags() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AccountStateTagged::clear_has_account_tags() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AccountStateTagged::clear_account_tags() {
+  if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear();
+  clear_has_account_tags();
+}
+inline const ::bgs::protocol::account::v1::AccountFieldTags& AccountStateTagged::account_tags() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountStateTagged.account_tags)
+  return account_tags_ != NULL ? *account_tags_ : *default_instance_->account_tags_;
+}
+inline ::bgs::protocol::account::v1::AccountFieldTags* AccountStateTagged::mutable_account_tags() {
+  set_has_account_tags();
+  if (account_tags_ == NULL) account_tags_ = new ::bgs::protocol::account::v1::AccountFieldTags;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountStateTagged.account_tags)
+  return account_tags_;
+}
+inline ::bgs::protocol::account::v1::AccountFieldTags* AccountStateTagged::release_account_tags() {
+  clear_has_account_tags();
+  ::bgs::protocol::account::v1::AccountFieldTags* temp = account_tags_;
+  account_tags_ = NULL;
+  return temp;
+}
+inline void AccountStateTagged::set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags) {
+  delete account_tags_;
+  account_tags_ = account_tags;
+  if (account_tags) {
+    set_has_account_tags();
+  } else {
+    clear_has_account_tags();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountStateTagged.account_tags)
+}
+
+// -------------------------------------------------------------------
+
+// GameAccountState
+
+// optional .bgs.protocol.account.v1.GameLevelInfo game_level_info = 1;
+inline bool GameAccountState::has_game_level_info() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameAccountState::set_has_game_level_info() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameAccountState::clear_has_game_level_info() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameAccountState::clear_game_level_info() {
+  if (game_level_info_ != NULL) game_level_info_->::bgs::protocol::account::v1::GameLevelInfo::Clear();
+  clear_has_game_level_info();
+}
+inline const ::bgs::protocol::account::v1::GameLevelInfo& GameAccountState::game_level_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountState.game_level_info)
+  return game_level_info_ != NULL ? *game_level_info_ : *default_instance_->game_level_info_;
+}
+inline ::bgs::protocol::account::v1::GameLevelInfo* GameAccountState::mutable_game_level_info() {
+  set_has_game_level_info();
+  if (game_level_info_ == NULL) game_level_info_ = new ::bgs::protocol::account::v1::GameLevelInfo;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountState.game_level_info)
+  return game_level_info_;
+}
+inline ::bgs::protocol::account::v1::GameLevelInfo* GameAccountState::release_game_level_info() {
+  clear_has_game_level_info();
+  ::bgs::protocol::account::v1::GameLevelInfo* temp = game_level_info_;
+  game_level_info_ = NULL;
+  return temp;
+}
+inline void GameAccountState::set_allocated_game_level_info(::bgs::protocol::account::v1::GameLevelInfo* game_level_info) {
+  delete game_level_info_;
+  game_level_info_ = game_level_info;
+  if (game_level_info) {
+    set_has_game_level_info();
+  } else {
+    clear_has_game_level_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountState.game_level_info)
+}
+
+// optional .bgs.protocol.account.v1.GameTimeInfo game_time_info = 2;
+inline bool GameAccountState::has_game_time_info() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameAccountState::set_has_game_time_info() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameAccountState::clear_has_game_time_info() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameAccountState::clear_game_time_info() {
+  if (game_time_info_ != NULL) game_time_info_->::bgs::protocol::account::v1::GameTimeInfo::Clear();
+  clear_has_game_time_info();
+}
+inline const ::bgs::protocol::account::v1::GameTimeInfo& GameAccountState::game_time_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountState.game_time_info)
+  return game_time_info_ != NULL ? *game_time_info_ : *default_instance_->game_time_info_;
+}
+inline ::bgs::protocol::account::v1::GameTimeInfo* GameAccountState::mutable_game_time_info() {
+  set_has_game_time_info();
+  if (game_time_info_ == NULL) game_time_info_ = new ::bgs::protocol::account::v1::GameTimeInfo;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountState.game_time_info)
+  return game_time_info_;
+}
+inline ::bgs::protocol::account::v1::GameTimeInfo* GameAccountState::release_game_time_info() {
+  clear_has_game_time_info();
+  ::bgs::protocol::account::v1::GameTimeInfo* temp = game_time_info_;
+  game_time_info_ = NULL;
+  return temp;
+}
+inline void GameAccountState::set_allocated_game_time_info(::bgs::protocol::account::v1::GameTimeInfo* game_time_info) {
+  delete game_time_info_;
+  game_time_info_ = game_time_info;
+  if (game_time_info) {
+    set_has_game_time_info();
+  } else {
+    clear_has_game_time_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountState.game_time_info)
+}
+
+// optional .bgs.protocol.account.v1.GameStatus game_status = 3;
+inline bool GameAccountState::has_game_status() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GameAccountState::set_has_game_status() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GameAccountState::clear_has_game_status() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GameAccountState::clear_game_status() {
+  if (game_status_ != NULL) game_status_->::bgs::protocol::account::v1::GameStatus::Clear();
+  clear_has_game_status();
+}
+inline const ::bgs::protocol::account::v1::GameStatus& GameAccountState::game_status() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountState.game_status)
+  return game_status_ != NULL ? *game_status_ : *default_instance_->game_status_;
+}
+inline ::bgs::protocol::account::v1::GameStatus* GameAccountState::mutable_game_status() {
+  set_has_game_status();
+  if (game_status_ == NULL) game_status_ = new ::bgs::protocol::account::v1::GameStatus;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountState.game_status)
+  return game_status_;
+}
+inline ::bgs::protocol::account::v1::GameStatus* GameAccountState::release_game_status() {
+  clear_has_game_status();
+  ::bgs::protocol::account::v1::GameStatus* temp = game_status_;
+  game_status_ = NULL;
+  return temp;
+}
+inline void GameAccountState::set_allocated_game_status(::bgs::protocol::account::v1::GameStatus* game_status) {
+  delete game_status_;
+  game_status_ = game_status;
+  if (game_status) {
+    set_has_game_status();
+  } else {
+    clear_has_game_status();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountState.game_status)
+}
+
+// optional .bgs.protocol.account.v1.RAFInfo raf_info = 4;
+inline bool GameAccountState::has_raf_info() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GameAccountState::set_has_raf_info() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GameAccountState::clear_has_raf_info() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GameAccountState::clear_raf_info() {
+  if (raf_info_ != NULL) raf_info_->::bgs::protocol::account::v1::RAFInfo::Clear();
+  clear_has_raf_info();
+}
+inline const ::bgs::protocol::account::v1::RAFInfo& GameAccountState::raf_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountState.raf_info)
+  return raf_info_ != NULL ? *raf_info_ : *default_instance_->raf_info_;
+}
+inline ::bgs::protocol::account::v1::RAFInfo* GameAccountState::mutable_raf_info() {
+  set_has_raf_info();
+  if (raf_info_ == NULL) raf_info_ = new ::bgs::protocol::account::v1::RAFInfo;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountState.raf_info)
+  return raf_info_;
+}
+inline ::bgs::protocol::account::v1::RAFInfo* GameAccountState::release_raf_info() {
+  clear_has_raf_info();
+  ::bgs::protocol::account::v1::RAFInfo* temp = raf_info_;
+  raf_info_ = NULL;
+  return temp;
+}
+inline void GameAccountState::set_allocated_raf_info(::bgs::protocol::account::v1::RAFInfo* raf_info) {
+  delete raf_info_;
+  raf_info_ = raf_info;
+  if (raf_info) {
+    set_has_raf_info();
+  } else {
+    clear_has_raf_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountState.raf_info)
+}
+
+// -------------------------------------------------------------------
+
+// GameAccountStateTagged
+
+// optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1;
+inline bool GameAccountStateTagged::has_game_account_state() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameAccountStateTagged::set_has_game_account_state() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameAccountStateTagged::clear_has_game_account_state() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameAccountStateTagged::clear_game_account_state() {
+  if (game_account_state_ != NULL) game_account_state_->::bgs::protocol::account::v1::GameAccountState::Clear();
+  clear_has_game_account_state();
+}
+inline const ::bgs::protocol::account::v1::GameAccountState& GameAccountStateTagged::game_account_state() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountStateTagged.game_account_state)
+  return game_account_state_ != NULL ? *game_account_state_ : *default_instance_->game_account_state_;
+}
+inline ::bgs::protocol::account::v1::GameAccountState* GameAccountStateTagged::mutable_game_account_state() {
+  set_has_game_account_state();
+  if (game_account_state_ == NULL) game_account_state_ = new ::bgs::protocol::account::v1::GameAccountState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountStateTagged.game_account_state)
+  return game_account_state_;
+}
+inline ::bgs::protocol::account::v1::GameAccountState* GameAccountStateTagged::release_game_account_state() {
+  clear_has_game_account_state();
+  ::bgs::protocol::account::v1::GameAccountState* temp = game_account_state_;
+  game_account_state_ = NULL;
+  return temp;
+}
+inline void GameAccountStateTagged::set_allocated_game_account_state(::bgs::protocol::account::v1::GameAccountState* game_account_state) {
+  delete game_account_state_;
+  game_account_state_ = game_account_state;
+  if (game_account_state) {
+    set_has_game_account_state();
+  } else {
+    clear_has_game_account_state();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountStateTagged.game_account_state)
+}
+
+// optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 2;
+inline bool GameAccountStateTagged::has_game_account_tags() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameAccountStateTagged::set_has_game_account_tags() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameAccountStateTagged::clear_has_game_account_tags() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameAccountStateTagged::clear_game_account_tags() {
+  if (game_account_tags_ != NULL) game_account_tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear();
+  clear_has_game_account_tags();
+}
+inline const ::bgs::protocol::account::v1::GameAccountFieldTags& GameAccountStateTagged::game_account_tags() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountStateTagged.game_account_tags)
+  return game_account_tags_ != NULL ? *game_account_tags_ : *default_instance_->game_account_tags_;
+}
+inline ::bgs::protocol::account::v1::GameAccountFieldTags* GameAccountStateTagged::mutable_game_account_tags() {
+  set_has_game_account_tags();
+  if (game_account_tags_ == NULL) game_account_tags_ = new ::bgs::protocol::account::v1::GameAccountFieldTags;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountStateTagged.game_account_tags)
+  return game_account_tags_;
+}
+inline ::bgs::protocol::account::v1::GameAccountFieldTags* GameAccountStateTagged::release_game_account_tags() {
+  clear_has_game_account_tags();
+  ::bgs::protocol::account::v1::GameAccountFieldTags* temp = game_account_tags_;
+  game_account_tags_ = NULL;
+  return temp;
+}
+inline void GameAccountStateTagged::set_allocated_game_account_tags(::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags) {
+  delete game_account_tags_;
+  game_account_tags_ = game_account_tags;
+  if (game_account_tags) {
+    set_has_game_account_tags();
+  } else {
+    clear_has_game_account_tags();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountStateTagged.game_account_tags)
+}
+
+// -------------------------------------------------------------------
+
+// AuthorizedData
+
+// optional string data = 1;
+inline bool AuthorizedData::has_data() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AuthorizedData::set_has_data() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AuthorizedData::clear_has_data() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AuthorizedData::clear_data() {
+  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    data_->clear();
+  }
+  clear_has_data();
+}
+inline const ::std::string& AuthorizedData::data() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AuthorizedData.data)
+  return *data_;
+}
+inline void AuthorizedData::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.account.v1.AuthorizedData.data)
+}
+inline void AuthorizedData::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.account.v1.AuthorizedData.data)
+}
+inline void AuthorizedData::set_data(const char* 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.account.v1.AuthorizedData.data)
+}
+inline ::std::string* AuthorizedData::mutable_data() {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    data_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AuthorizedData.data)
+  return data_;
+}
+inline ::std::string* AuthorizedData::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 AuthorizedData::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.account.v1.AuthorizedData.data)
+}
+
+// repeated uint32 license = 2;
+inline int AuthorizedData::license_size() const {
+  return license_.size();
+}
+inline void AuthorizedData::clear_license() {
+  license_.Clear();
+}
+inline ::google::protobuf::uint32 AuthorizedData::license(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AuthorizedData.license)
+  return license_.Get(index);
+}
+inline void AuthorizedData::set_license(int index, ::google::protobuf::uint32 value) {
+  license_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AuthorizedData.license)
+}
+inline void AuthorizedData::add_license(::google::protobuf::uint32 value) {
+  license_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.AuthorizedData.license)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+AuthorizedData::license() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.AuthorizedData.license)
+  return license_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+AuthorizedData::mutable_license() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.AuthorizedData.license)
+  return &license_;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace account
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy>() {
+  return ::bgs::protocol::account::v1::PrivacyInfo_GameInfoPrivacy_descriptor();
+}
+template <> struct is_proto_enum< ::bgs::protocol::account::v1::IdentityVerificationStatus> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::account::v1::IdentityVerificationStatus>() {
+  return ::bgs::protocol::account::v1::IdentityVerificationStatus_descriptor();
+}
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_account_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/attribute_types.pb.cc b/src/server/proto/Client/attribute_types.pb.cc
new file mode 100644
index 00000000000..105a72cf1bb
--- /dev/null
+++ b/src/server/proto/Client/attribute_types.pb.cc
@@ -0,0 +1,1385 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: attribute_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "attribute_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+
+namespace {
+
+const ::google::protobuf::Descriptor* Variant_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Variant_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Attribute_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Attribute_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AttributeFilter_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AttributeFilter_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* AttributeFilter_Operation_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_attribute_5ftypes_2eproto() {
+  protobuf_AddDesc_attribute_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "attribute_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  Variant_descriptor_ = file->message_type(0);
+  static const int Variant_offsets_[9] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, bool_value_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, int_value_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, float_value_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, string_value_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, blob_value_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, message_value_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, fourcc_value_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, uint_value_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, entity_id_value_),
+  };
+  Variant_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Variant_descriptor_,
+      Variant::default_instance_,
+      Variant_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Variant, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Variant));
+  Attribute_descriptor_ = file->message_type(1);
+  static const int Attribute_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Attribute, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Attribute, value_),
+  };
+  Attribute_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Attribute_descriptor_,
+      Attribute::default_instance_,
+      Attribute_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Attribute, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Attribute, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Attribute));
+  AttributeFilter_descriptor_ = file->message_type(2);
+  static const int AttributeFilter_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttributeFilter, op_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttributeFilter, attribute_),
+  };
+  AttributeFilter_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AttributeFilter_descriptor_,
+      AttributeFilter::default_instance_,
+      AttributeFilter_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttributeFilter, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AttributeFilter, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AttributeFilter));
+  AttributeFilter_Operation_descriptor_ = AttributeFilter_descriptor_->enum_type(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_attribute_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Variant_descriptor_, &Variant::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Attribute_descriptor_, &Attribute::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AttributeFilter_descriptor_, &AttributeFilter::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_attribute_5ftypes_2eproto() {
+  delete Variant::default_instance_;
+  delete Variant_reflection_;
+  delete Attribute::default_instance_;
+  delete Attribute_reflection_;
+  delete AttributeFilter::default_instance_;
+  delete AttributeFilter_reflection_;
+}
+
+void protobuf_AddDesc_attribute_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\025attribute_types.proto\022\014bgs.protocol\032\022e"
+    "ntity_types.proto\"\341\001\n\007Variant\022\022\n\nbool_va"
+    "lue\030\002 \001(\010\022\021\n\tint_value\030\003 \001(\003\022\023\n\013float_va"
+    "lue\030\004 \001(\001\022\024\n\014string_value\030\005 \001(\t\022\022\n\nblob_"
+    "value\030\006 \001(\014\022\025\n\rmessage_value\030\007 \001(\014\022\024\n\014fo"
+    "urcc_value\030\010 \001(\t\022\022\n\nuint_value\030\t \001(\004\022/\n\017"
+    "entity_id_value\030\n \001(\0132\026.bgs.protocol.Ent"
+    "ityId\"\?\n\tAttribute\022\014\n\004name\030\001 \002(\t\022$\n\005valu"
+    "e\030\002 \002(\0132\025.bgs.protocol.Variant\"\312\001\n\017Attri"
+    "buteFilter\0223\n\002op\030\001 \002(\0162\'.bgs.protocol.At"
+    "tributeFilter.Operation\022*\n\tattribute\030\002 \003"
+    "(\0132\027.bgs.protocol.Attribute\"V\n\tOperation"
+    "\022\016\n\nMATCH_NONE\020\000\022\r\n\tMATCH_ANY\020\001\022\r\n\tMATCH"
+    "_ALL\020\002\022\033\n\027MATCH_ALL_MOST_SPECIFIC\020\003B!\n\rb"
+    "net.protocolB\016AttributeProtoH\001", 590);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "attribute_types.proto", &protobuf_RegisterTypes);
+  Variant::default_instance_ = new Variant();
+  Attribute::default_instance_ = new Attribute();
+  AttributeFilter::default_instance_ = new AttributeFilter();
+  Variant::default_instance_->InitAsDefaultInstance();
+  Attribute::default_instance_->InitAsDefaultInstance();
+  AttributeFilter::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_attribute_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_attribute_5ftypes_2eproto {
+  StaticDescriptorInitializer_attribute_5ftypes_2eproto() {
+    protobuf_AddDesc_attribute_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_attribute_5ftypes_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Variant::kBoolValueFieldNumber;
+const int Variant::kIntValueFieldNumber;
+const int Variant::kFloatValueFieldNumber;
+const int Variant::kStringValueFieldNumber;
+const int Variant::kBlobValueFieldNumber;
+const int Variant::kMessageValueFieldNumber;
+const int Variant::kFourccValueFieldNumber;
+const int Variant::kUintValueFieldNumber;
+const int Variant::kEntityIdValueFieldNumber;
+#endif  // !_MSC_VER
+
+Variant::Variant()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.Variant)
+}
+
+void Variant::InitAsDefaultInstance() {
+  entity_id_value_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+Variant::Variant(const Variant& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.Variant)
+}
+
+void Variant::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  bool_value_ = false;
+  int_value_ = GOOGLE_LONGLONG(0);
+  float_value_ = 0;
+  string_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  blob_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  message_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  fourcc_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  uint_value_ = GOOGLE_ULONGLONG(0);
+  entity_id_value_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Variant::~Variant() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.Variant)
+  SharedDtor();
+}
+
+void Variant::SharedDtor() {
+  if (string_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete string_value_;
+  }
+  if (blob_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete blob_value_;
+  }
+  if (message_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete message_value_;
+  }
+  if (fourcc_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete fourcc_value_;
+  }
+  if (this != default_instance_) {
+    delete entity_id_value_;
+  }
+}
+
+void Variant::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Variant::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Variant_descriptor_;
+}
+
+const Variant& Variant::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_attribute_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Variant* Variant::default_instance_ = NULL;
+
+Variant* Variant::New() const {
+  return new Variant;
+}
+
+void Variant::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<Variant*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 255) {
+    ZR_(int_value_, float_value_);
+    bool_value_ = false;
+    if (has_string_value()) {
+      if (string_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        string_value_->clear();
+      }
+    }
+    if (has_blob_value()) {
+      if (blob_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        blob_value_->clear();
+      }
+    }
+    if (has_message_value()) {
+      if (message_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        message_value_->clear();
+      }
+    }
+    if (has_fourcc_value()) {
+      if (fourcc_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        fourcc_value_->clear();
+      }
+    }
+    uint_value_ = GOOGLE_ULONGLONG(0);
+  }
+  if (has_entity_id_value()) {
+    if (entity_id_value_ != NULL) entity_id_value_->::bgs::protocol::EntityId::Clear();
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Variant::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.Variant)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bool bool_value = 2;
+      case 2: {
+        if (tag == 16) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &bool_value_)));
+          set_has_bool_value();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_int_value;
+        break;
+      }
+
+      // optional int64 int_value = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_int_value:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int64, ::google::protobuf::internal::WireFormatLite::TYPE_INT64>(
+                 input, &int_value_)));
+          set_has_int_value();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(33)) goto parse_float_value;
+        break;
+      }
+
+      // optional double float_value = 4;
+      case 4: {
+        if (tag == 33) {
+         parse_float_value:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &float_value_)));
+          set_has_float_value();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_string_value;
+        break;
+      }
+
+      // optional string string_value = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_string_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_string_value()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->string_value().data(), this->string_value().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "string_value");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_blob_value;
+        break;
+      }
+
+      // optional bytes blob_value = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_blob_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_blob_value()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_message_value;
+        break;
+      }
+
+      // optional bytes message_value = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_message_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_message_value()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_fourcc_value;
+        break;
+      }
+
+      // optional string fourcc_value = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_fourcc_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_fourcc_value()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->fourcc_value().data(), this->fourcc_value().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "fourcc_value");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(72)) goto parse_uint_value;
+        break;
+      }
+
+      // optional uint64 uint_value = 9;
+      case 9: {
+        if (tag == 72) {
+         parse_uint_value:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &uint_value_)));
+          set_has_uint_value();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_entity_id_value;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId entity_id_value = 10;
+      case 10: {
+        if (tag == 82) {
+         parse_entity_id_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id_value()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.Variant)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.Variant)
+  return false;
+#undef DO_
+}
+
+void Variant::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.Variant)
+  // optional bool bool_value = 2;
+  if (has_bool_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->bool_value(), output);
+  }
+
+  // optional int64 int_value = 3;
+  if (has_int_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt64(3, this->int_value(), output);
+  }
+
+  // optional double float_value = 4;
+  if (has_float_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(4, this->float_value(), output);
+  }
+
+  // optional string string_value = 5;
+  if (has_string_value()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->string_value().data(), this->string_value().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "string_value");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      5, this->string_value(), output);
+  }
+
+  // optional bytes blob_value = 6;
+  if (has_blob_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      6, this->blob_value(), output);
+  }
+
+  // optional bytes message_value = 7;
+  if (has_message_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      7, this->message_value(), output);
+  }
+
+  // optional string fourcc_value = 8;
+  if (has_fourcc_value()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->fourcc_value().data(), this->fourcc_value().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "fourcc_value");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      8, this->fourcc_value(), output);
+  }
+
+  // optional uint64 uint_value = 9;
+  if (has_uint_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(9, this->uint_value(), output);
+  }
+
+  // optional .bgs.protocol.EntityId entity_id_value = 10;
+  if (has_entity_id_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      10, this->entity_id_value(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.Variant)
+}
+
+::google::protobuf::uint8* Variant::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Variant)
+  // optional bool bool_value = 2;
+  if (has_bool_value()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->bool_value(), target);
+  }
+
+  // optional int64 int_value = 3;
+  if (has_int_value()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt64ToArray(3, this->int_value(), target);
+  }
+
+  // optional double float_value = 4;
+  if (has_float_value()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(4, this->float_value(), target);
+  }
+
+  // optional string string_value = 5;
+  if (has_string_value()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->string_value().data(), this->string_value().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "string_value");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->string_value(), target);
+  }
+
+  // optional bytes blob_value = 6;
+  if (has_blob_value()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        6, this->blob_value(), target);
+  }
+
+  // optional bytes message_value = 7;
+  if (has_message_value()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        7, this->message_value(), target);
+  }
+
+  // optional string fourcc_value = 8;
+  if (has_fourcc_value()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->fourcc_value().data(), this->fourcc_value().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "fourcc_value");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        8, this->fourcc_value(), target);
+  }
+
+  // optional uint64 uint_value = 9;
+  if (has_uint_value()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(9, this->uint_value(), target);
+  }
+
+  // optional .bgs.protocol.EntityId entity_id_value = 10;
+  if (has_entity_id_value()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        10, this->entity_id_value(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Variant)
+  return target;
+}
+
+int Variant::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bool bool_value = 2;
+    if (has_bool_value()) {
+      total_size += 1 + 1;
+    }
+
+    // optional int64 int_value = 3;
+    if (has_int_value()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int64Size(
+          this->int_value());
+    }
+
+    // optional double float_value = 4;
+    if (has_float_value()) {
+      total_size += 1 + 8;
+    }
+
+    // optional string string_value = 5;
+    if (has_string_value()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->string_value());
+    }
+
+    // optional bytes blob_value = 6;
+    if (has_blob_value()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->blob_value());
+    }
+
+    // optional bytes message_value = 7;
+    if (has_message_value()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->message_value());
+    }
+
+    // optional string fourcc_value = 8;
+    if (has_fourcc_value()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->fourcc_value());
+    }
+
+    // optional uint64 uint_value = 9;
+    if (has_uint_value()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->uint_value());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional .bgs.protocol.EntityId entity_id_value = 10;
+    if (has_entity_id_value()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id_value());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Variant::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Variant* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Variant*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Variant::MergeFrom(const Variant& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_bool_value()) {
+      set_bool_value(from.bool_value());
+    }
+    if (from.has_int_value()) {
+      set_int_value(from.int_value());
+    }
+    if (from.has_float_value()) {
+      set_float_value(from.float_value());
+    }
+    if (from.has_string_value()) {
+      set_string_value(from.string_value());
+    }
+    if (from.has_blob_value()) {
+      set_blob_value(from.blob_value());
+    }
+    if (from.has_message_value()) {
+      set_message_value(from.message_value());
+    }
+    if (from.has_fourcc_value()) {
+      set_fourcc_value(from.fourcc_value());
+    }
+    if (from.has_uint_value()) {
+      set_uint_value(from.uint_value());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_entity_id_value()) {
+      mutable_entity_id_value()->::bgs::protocol::EntityId::MergeFrom(from.entity_id_value());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Variant::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Variant::CopyFrom(const Variant& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Variant::IsInitialized() const {
+
+  if (has_entity_id_value()) {
+    if (!this->entity_id_value().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void Variant::Swap(Variant* other) {
+  if (other != this) {
+    std::swap(bool_value_, other->bool_value_);
+    std::swap(int_value_, other->int_value_);
+    std::swap(float_value_, other->float_value_);
+    std::swap(string_value_, other->string_value_);
+    std::swap(blob_value_, other->blob_value_);
+    std::swap(message_value_, other->message_value_);
+    std::swap(fourcc_value_, other->fourcc_value_);
+    std::swap(uint_value_, other->uint_value_);
+    std::swap(entity_id_value_, other->entity_id_value_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Variant::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Variant_descriptor_;
+  metadata.reflection = Variant_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Attribute::kNameFieldNumber;
+const int Attribute::kValueFieldNumber;
+#endif  // !_MSC_VER
+
+Attribute::Attribute()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.Attribute)
+}
+
+void Attribute::InitAsDefaultInstance() {
+  value_ = const_cast< ::bgs::protocol::Variant*>(&::bgs::protocol::Variant::default_instance());
+}
+
+Attribute::Attribute(const Attribute& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.Attribute)
+}
+
+void Attribute::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  value_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Attribute::~Attribute() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.Attribute)
+  SharedDtor();
+}
+
+void Attribute::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (this != default_instance_) {
+    delete value_;
+  }
+}
+
+void Attribute::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Attribute::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Attribute_descriptor_;
+}
+
+const Attribute& Attribute::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_attribute_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Attribute* Attribute::default_instance_ = NULL;
+
+Attribute* Attribute::New() const {
+  return new Attribute;
+}
+
+void Attribute::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    if (has_value()) {
+      if (value_ != NULL) value_->::bgs::protocol::Variant::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Attribute::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.Attribute)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required string name = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_value;
+        break;
+      }
+
+      // required .bgs.protocol.Variant value = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_value()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.Attribute)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.Attribute)
+  return false;
+#undef DO_
+}
+
+void Attribute::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.Attribute)
+  // required string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->name(), output);
+  }
+
+  // required .bgs.protocol.Variant value = 2;
+  if (has_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->value(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.Attribute)
+}
+
+::google::protobuf::uint8* Attribute::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Attribute)
+  // required string name = 1;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->name(), target);
+  }
+
+  // required .bgs.protocol.Variant value = 2;
+  if (has_value()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->value(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Attribute)
+  return target;
+}
+
+int Attribute::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required string name = 1;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // required .bgs.protocol.Variant value = 2;
+    if (has_value()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->value());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Attribute::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Attribute* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Attribute*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Attribute::MergeFrom(const Attribute& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_value()) {
+      mutable_value()->::bgs::protocol::Variant::MergeFrom(from.value());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Attribute::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Attribute::CopyFrom(const Attribute& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Attribute::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  if (has_value()) {
+    if (!this->value().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void Attribute::Swap(Attribute* other) {
+  if (other != this) {
+    std::swap(name_, other->name_);
+    std::swap(value_, other->value_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Attribute::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Attribute_descriptor_;
+  metadata.reflection = Attribute_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+const ::google::protobuf::EnumDescriptor* AttributeFilter_Operation_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AttributeFilter_Operation_descriptor_;
+}
+bool AttributeFilter_Operation_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const AttributeFilter_Operation AttributeFilter::MATCH_NONE;
+const AttributeFilter_Operation AttributeFilter::MATCH_ANY;
+const AttributeFilter_Operation AttributeFilter::MATCH_ALL;
+const AttributeFilter_Operation AttributeFilter::MATCH_ALL_MOST_SPECIFIC;
+const AttributeFilter_Operation AttributeFilter::Operation_MIN;
+const AttributeFilter_Operation AttributeFilter::Operation_MAX;
+const int AttributeFilter::Operation_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int AttributeFilter::kOpFieldNumber;
+const int AttributeFilter::kAttributeFieldNumber;
+#endif  // !_MSC_VER
+
+AttributeFilter::AttributeFilter()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.AttributeFilter)
+}
+
+void AttributeFilter::InitAsDefaultInstance() {
+}
+
+AttributeFilter::AttributeFilter(const AttributeFilter& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.AttributeFilter)
+}
+
+void AttributeFilter::SharedCtor() {
+  _cached_size_ = 0;
+  op_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AttributeFilter::~AttributeFilter() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.AttributeFilter)
+  SharedDtor();
+}
+
+void AttributeFilter::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void AttributeFilter::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AttributeFilter::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AttributeFilter_descriptor_;
+}
+
+const AttributeFilter& AttributeFilter::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_attribute_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+AttributeFilter* AttributeFilter::default_instance_ = NULL;
+
+AttributeFilter* AttributeFilter::New() const {
+  return new AttributeFilter;
+}
+
+void AttributeFilter::Clear() {
+  op_ = 0;
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AttributeFilter::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.AttributeFilter)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.AttributeFilter.Operation op = 1;
+      case 1: {
+        if (tag == 8) {
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::AttributeFilter_Operation_IsValid(value)) {
+            set_op(static_cast< ::bgs::protocol::AttributeFilter_Operation >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(1, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.Attribute attribute = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.AttributeFilter)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.AttributeFilter)
+  return false;
+#undef DO_
+}
+
+void AttributeFilter::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.AttributeFilter)
+  // required .bgs.protocol.AttributeFilter.Operation op = 1;
+  if (has_op()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      1, this->op(), output);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->attribute(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.AttributeFilter)
+}
+
+::google::protobuf::uint8* AttributeFilter::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.AttributeFilter)
+  // required .bgs.protocol.AttributeFilter.Operation op = 1;
+  if (has_op()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      1, this->op(), target);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->attribute(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.AttributeFilter)
+  return target;
+}
+
+int AttributeFilter::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.AttributeFilter.Operation op = 1;
+    if (has_op()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->op());
+    }
+
+  }
+  // repeated .bgs.protocol.Attribute attribute = 2;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AttributeFilter::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AttributeFilter* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AttributeFilter*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AttributeFilter::MergeFrom(const AttributeFilter& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_op()) {
+      set_op(from.op());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AttributeFilter::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AttributeFilter::CopyFrom(const AttributeFilter& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AttributeFilter::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
+  return true;
+}
+
+void AttributeFilter::Swap(AttributeFilter* other) {
+  if (other != this) {
+    std::swap(op_, other->op_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AttributeFilter::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AttributeFilter_descriptor_;
+  metadata.reflection = AttributeFilter_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/attribute_types.pb.h b/src/server/proto/Client/attribute_types.pb.h
new file mode 100644
index 00000000000..78c3e1caf0a
--- /dev/null
+++ b/src/server/proto/Client/attribute_types.pb.h
@@ -0,0 +1,1113 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: attribute_types.proto
+
+#ifndef PROTOBUF_attribute_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_attribute_5ftypes_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/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "entity_types.pb.h"
+#include "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_attribute_5ftypes_2eproto();
+void protobuf_AssignDesc_attribute_5ftypes_2eproto();
+void protobuf_ShutdownFile_attribute_5ftypes_2eproto();
+
+class Variant;
+class Attribute;
+class AttributeFilter;
+
+enum AttributeFilter_Operation {
+  AttributeFilter_Operation_MATCH_NONE = 0,
+  AttributeFilter_Operation_MATCH_ANY = 1,
+  AttributeFilter_Operation_MATCH_ALL = 2,
+  AttributeFilter_Operation_MATCH_ALL_MOST_SPECIFIC = 3
+};
+TC_SHARED_API bool AttributeFilter_Operation_IsValid(int value);
+const AttributeFilter_Operation AttributeFilter_Operation_Operation_MIN = AttributeFilter_Operation_MATCH_NONE;
+const AttributeFilter_Operation AttributeFilter_Operation_Operation_MAX = AttributeFilter_Operation_MATCH_ALL_MOST_SPECIFIC;
+const int AttributeFilter_Operation_Operation_ARRAYSIZE = AttributeFilter_Operation_Operation_MAX + 1;
+
+TC_SHARED_API const ::google::protobuf::EnumDescriptor* AttributeFilter_Operation_descriptor();
+inline const ::std::string& AttributeFilter_Operation_Name(AttributeFilter_Operation value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    AttributeFilter_Operation_descriptor(), value);
+}
+inline bool AttributeFilter_Operation_Parse(
+    const ::std::string& name, AttributeFilter_Operation* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<AttributeFilter_Operation>(
+    AttributeFilter_Operation_descriptor(), name, value);
+}
+// ===================================================================
+
+class TC_SHARED_API Variant : public ::google::protobuf::Message {
+ public:
+  Variant();
+  virtual ~Variant();
+
+  Variant(const Variant& from);
+
+  inline Variant& operator=(const Variant& 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 Variant& default_instance();
+
+  void Swap(Variant* other);
+
+  // implements Message ----------------------------------------------
+
+  Variant* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Variant& from);
+  void MergeFrom(const Variant& 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 bool bool_value = 2;
+  inline bool has_bool_value() const;
+  inline void clear_bool_value();
+  static const int kBoolValueFieldNumber = 2;
+  inline bool bool_value() const;
+  inline void set_bool_value(bool value);
+
+  // optional int64 int_value = 3;
+  inline bool has_int_value() const;
+  inline void clear_int_value();
+  static const int kIntValueFieldNumber = 3;
+  inline ::google::protobuf::int64 int_value() const;
+  inline void set_int_value(::google::protobuf::int64 value);
+
+  // optional double float_value = 4;
+  inline bool has_float_value() const;
+  inline void clear_float_value();
+  static const int kFloatValueFieldNumber = 4;
+  inline double float_value() const;
+  inline void set_float_value(double value);
+
+  // optional string string_value = 5;
+  inline bool has_string_value() const;
+  inline void clear_string_value();
+  static const int kStringValueFieldNumber = 5;
+  inline const ::std::string& string_value() const;
+  inline void set_string_value(const ::std::string& value);
+  inline void set_string_value(const char* value);
+  inline void set_string_value(const char* value, size_t size);
+  inline ::std::string* mutable_string_value();
+  inline ::std::string* release_string_value();
+  inline void set_allocated_string_value(::std::string* string_value);
+
+  // optional bytes blob_value = 6;
+  inline bool has_blob_value() const;
+  inline void clear_blob_value();
+  static const int kBlobValueFieldNumber = 6;
+  inline const ::std::string& blob_value() const;
+  inline void set_blob_value(const ::std::string& value);
+  inline void set_blob_value(const char* value);
+  inline void set_blob_value(const void* value, size_t size);
+  inline ::std::string* mutable_blob_value();
+  inline ::std::string* release_blob_value();
+  inline void set_allocated_blob_value(::std::string* blob_value);
+
+  // optional bytes message_value = 7;
+  inline bool has_message_value() const;
+  inline void clear_message_value();
+  static const int kMessageValueFieldNumber = 7;
+  inline const ::std::string& message_value() const;
+  inline void set_message_value(const ::std::string& value);
+  inline void set_message_value(const char* value);
+  inline void set_message_value(const void* value, size_t size);
+  inline ::std::string* mutable_message_value();
+  inline ::std::string* release_message_value();
+  inline void set_allocated_message_value(::std::string* message_value);
+
+  // optional string fourcc_value = 8;
+  inline bool has_fourcc_value() const;
+  inline void clear_fourcc_value();
+  static const int kFourccValueFieldNumber = 8;
+  inline const ::std::string& fourcc_value() const;
+  inline void set_fourcc_value(const ::std::string& value);
+  inline void set_fourcc_value(const char* value);
+  inline void set_fourcc_value(const char* value, size_t size);
+  inline ::std::string* mutable_fourcc_value();
+  inline ::std::string* release_fourcc_value();
+  inline void set_allocated_fourcc_value(::std::string* fourcc_value);
+
+  // optional uint64 uint_value = 9;
+  inline bool has_uint_value() const;
+  inline void clear_uint_value();
+  static const int kUintValueFieldNumber = 9;
+  inline ::google::protobuf::uint64 uint_value() const;
+  inline void set_uint_value(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.EntityId entity_id_value = 10;
+  inline bool has_entity_id_value() const;
+  inline void clear_entity_id_value();
+  static const int kEntityIdValueFieldNumber = 10;
+  inline const ::bgs::protocol::EntityId& entity_id_value() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id_value();
+  inline ::bgs::protocol::EntityId* release_entity_id_value();
+  inline void set_allocated_entity_id_value(::bgs::protocol::EntityId* entity_id_value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.Variant)
+ private:
+  inline void set_has_bool_value();
+  inline void clear_has_bool_value();
+  inline void set_has_int_value();
+  inline void clear_has_int_value();
+  inline void set_has_float_value();
+  inline void clear_has_float_value();
+  inline void set_has_string_value();
+  inline void clear_has_string_value();
+  inline void set_has_blob_value();
+  inline void clear_has_blob_value();
+  inline void set_has_message_value();
+  inline void clear_has_message_value();
+  inline void set_has_fourcc_value();
+  inline void clear_has_fourcc_value();
+  inline void set_has_uint_value();
+  inline void clear_has_uint_value();
+  inline void set_has_entity_id_value();
+  inline void clear_has_entity_id_value();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::int64 int_value_;
+  double float_value_;
+  ::std::string* string_value_;
+  ::std::string* blob_value_;
+  ::std::string* message_value_;
+  ::std::string* fourcc_value_;
+  ::google::protobuf::uint64 uint_value_;
+  ::bgs::protocol::EntityId* entity_id_value_;
+  bool bool_value_;
+  friend void TC_SHARED_API protobuf_AddDesc_attribute_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_attribute_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_attribute_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Variant* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API Attribute : public ::google::protobuf::Message {
+ public:
+  Attribute();
+  virtual ~Attribute();
+
+  Attribute(const Attribute& from);
+
+  inline Attribute& operator=(const Attribute& 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 Attribute& default_instance();
+
+  void Swap(Attribute* other);
+
+  // implements Message ----------------------------------------------
+
+  Attribute* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Attribute& from);
+  void MergeFrom(const Attribute& 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 string name = 1;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 1;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // required .bgs.protocol.Variant value = 2;
+  inline bool has_value() const;
+  inline void clear_value();
+  static const int kValueFieldNumber = 2;
+  inline const ::bgs::protocol::Variant& value() const;
+  inline ::bgs::protocol::Variant* mutable_value();
+  inline ::bgs::protocol::Variant* release_value();
+  inline void set_allocated_value(::bgs::protocol::Variant* value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.Attribute)
+ private:
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_value();
+  inline void clear_has_value();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* name_;
+  ::bgs::protocol::Variant* value_;
+  friend void TC_SHARED_API protobuf_AddDesc_attribute_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_attribute_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_attribute_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Attribute* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AttributeFilter : public ::google::protobuf::Message {
+ public:
+  AttributeFilter();
+  virtual ~AttributeFilter();
+
+  AttributeFilter(const AttributeFilter& from);
+
+  inline AttributeFilter& operator=(const AttributeFilter& 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 AttributeFilter& default_instance();
+
+  void Swap(AttributeFilter* other);
+
+  // implements Message ----------------------------------------------
+
+  AttributeFilter* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AttributeFilter& from);
+  void MergeFrom(const AttributeFilter& 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 ----------------------------------------------------
+
+  typedef AttributeFilter_Operation Operation;
+  static const Operation MATCH_NONE = AttributeFilter_Operation_MATCH_NONE;
+  static const Operation MATCH_ANY = AttributeFilter_Operation_MATCH_ANY;
+  static const Operation MATCH_ALL = AttributeFilter_Operation_MATCH_ALL;
+  static const Operation MATCH_ALL_MOST_SPECIFIC = AttributeFilter_Operation_MATCH_ALL_MOST_SPECIFIC;
+  static inline bool Operation_IsValid(int value) {
+    return AttributeFilter_Operation_IsValid(value);
+  }
+  static const Operation Operation_MIN =
+    AttributeFilter_Operation_Operation_MIN;
+  static const Operation Operation_MAX =
+    AttributeFilter_Operation_Operation_MAX;
+  static const int Operation_ARRAYSIZE =
+    AttributeFilter_Operation_Operation_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  Operation_descriptor() {
+    return AttributeFilter_Operation_descriptor();
+  }
+  static inline const ::std::string& Operation_Name(Operation value) {
+    return AttributeFilter_Operation_Name(value);
+  }
+  static inline bool Operation_Parse(const ::std::string& name,
+      Operation* value) {
+    return AttributeFilter_Operation_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  // required .bgs.protocol.AttributeFilter.Operation op = 1;
+  inline bool has_op() const;
+  inline void clear_op();
+  static const int kOpFieldNumber = 1;
+  inline ::bgs::protocol::AttributeFilter_Operation op() const;
+  inline void set_op(::bgs::protocol::AttributeFilter_Operation value);
+
+  // repeated .bgs.protocol.Attribute attribute = 2;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 2;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.AttributeFilter)
+ private:
+  inline void set_has_op();
+  inline void clear_has_op();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
+  int op_;
+  friend void TC_SHARED_API protobuf_AddDesc_attribute_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_attribute_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_attribute_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static AttributeFilter* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// Variant
+
+// optional bool bool_value = 2;
+inline bool Variant::has_bool_value() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Variant::set_has_bool_value() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Variant::clear_has_bool_value() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Variant::clear_bool_value() {
+  bool_value_ = false;
+  clear_has_bool_value();
+}
+inline bool Variant::bool_value() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Variant.bool_value)
+  return bool_value_;
+}
+inline void Variant::set_bool_value(bool value) {
+  set_has_bool_value();
+  bool_value_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Variant.bool_value)
+}
+
+// optional int64 int_value = 3;
+inline bool Variant::has_int_value() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Variant::set_has_int_value() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Variant::clear_has_int_value() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Variant::clear_int_value() {
+  int_value_ = GOOGLE_LONGLONG(0);
+  clear_has_int_value();
+}
+inline ::google::protobuf::int64 Variant::int_value() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Variant.int_value)
+  return int_value_;
+}
+inline void Variant::set_int_value(::google::protobuf::int64 value) {
+  set_has_int_value();
+  int_value_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Variant.int_value)
+}
+
+// optional double float_value = 4;
+inline bool Variant::has_float_value() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Variant::set_has_float_value() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Variant::clear_has_float_value() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Variant::clear_float_value() {
+  float_value_ = 0;
+  clear_has_float_value();
+}
+inline double Variant::float_value() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Variant.float_value)
+  return float_value_;
+}
+inline void Variant::set_float_value(double value) {
+  set_has_float_value();
+  float_value_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Variant.float_value)
+}
+
+// optional string string_value = 5;
+inline bool Variant::has_string_value() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Variant::set_has_string_value() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Variant::clear_has_string_value() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Variant::clear_string_value() {
+  if (string_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    string_value_->clear();
+  }
+  clear_has_string_value();
+}
+inline const ::std::string& Variant::string_value() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Variant.string_value)
+  return *string_value_;
+}
+inline void Variant::set_string_value(const ::std::string& value) {
+  set_has_string_value();
+  if (string_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    string_value_ = new ::std::string;
+  }
+  string_value_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.Variant.string_value)
+}
+inline void Variant::set_string_value(const char* value) {
+  set_has_string_value();
+  if (string_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    string_value_ = new ::std::string;
+  }
+  string_value_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.Variant.string_value)
+}
+inline void Variant::set_string_value(const char* value, size_t size) {
+  set_has_string_value();
+  if (string_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    string_value_ = new ::std::string;
+  }
+  string_value_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Variant.string_value)
+}
+inline ::std::string* Variant::mutable_string_value() {
+  set_has_string_value();
+  if (string_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    string_value_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Variant.string_value)
+  return string_value_;
+}
+inline ::std::string* Variant::release_string_value() {
+  clear_has_string_value();
+  if (string_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = string_value_;
+    string_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Variant::set_allocated_string_value(::std::string* string_value) {
+  if (string_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete string_value_;
+  }
+  if (string_value) {
+    set_has_string_value();
+    string_value_ = string_value;
+  } else {
+    clear_has_string_value();
+    string_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Variant.string_value)
+}
+
+// optional bytes blob_value = 6;
+inline bool Variant::has_blob_value() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void Variant::set_has_blob_value() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void Variant::clear_has_blob_value() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void Variant::clear_blob_value() {
+  if (blob_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    blob_value_->clear();
+  }
+  clear_has_blob_value();
+}
+inline const ::std::string& Variant::blob_value() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Variant.blob_value)
+  return *blob_value_;
+}
+inline void Variant::set_blob_value(const ::std::string& value) {
+  set_has_blob_value();
+  if (blob_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    blob_value_ = new ::std::string;
+  }
+  blob_value_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.Variant.blob_value)
+}
+inline void Variant::set_blob_value(const char* value) {
+  set_has_blob_value();
+  if (blob_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    blob_value_ = new ::std::string;
+  }
+  blob_value_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.Variant.blob_value)
+}
+inline void Variant::set_blob_value(const void* value, size_t size) {
+  set_has_blob_value();
+  if (blob_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    blob_value_ = new ::std::string;
+  }
+  blob_value_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Variant.blob_value)
+}
+inline ::std::string* Variant::mutable_blob_value() {
+  set_has_blob_value();
+  if (blob_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    blob_value_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Variant.blob_value)
+  return blob_value_;
+}
+inline ::std::string* Variant::release_blob_value() {
+  clear_has_blob_value();
+  if (blob_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = blob_value_;
+    blob_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Variant::set_allocated_blob_value(::std::string* blob_value) {
+  if (blob_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete blob_value_;
+  }
+  if (blob_value) {
+    set_has_blob_value();
+    blob_value_ = blob_value;
+  } else {
+    clear_has_blob_value();
+    blob_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Variant.blob_value)
+}
+
+// optional bytes message_value = 7;
+inline bool Variant::has_message_value() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void Variant::set_has_message_value() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void Variant::clear_has_message_value() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void Variant::clear_message_value() {
+  if (message_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    message_value_->clear();
+  }
+  clear_has_message_value();
+}
+inline const ::std::string& Variant::message_value() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Variant.message_value)
+  return *message_value_;
+}
+inline void Variant::set_message_value(const ::std::string& value) {
+  set_has_message_value();
+  if (message_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    message_value_ = new ::std::string;
+  }
+  message_value_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.Variant.message_value)
+}
+inline void Variant::set_message_value(const char* value) {
+  set_has_message_value();
+  if (message_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    message_value_ = new ::std::string;
+  }
+  message_value_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.Variant.message_value)
+}
+inline void Variant::set_message_value(const void* value, size_t size) {
+  set_has_message_value();
+  if (message_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    message_value_ = new ::std::string;
+  }
+  message_value_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Variant.message_value)
+}
+inline ::std::string* Variant::mutable_message_value() {
+  set_has_message_value();
+  if (message_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    message_value_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Variant.message_value)
+  return message_value_;
+}
+inline ::std::string* Variant::release_message_value() {
+  clear_has_message_value();
+  if (message_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = message_value_;
+    message_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Variant::set_allocated_message_value(::std::string* message_value) {
+  if (message_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete message_value_;
+  }
+  if (message_value) {
+    set_has_message_value();
+    message_value_ = message_value;
+  } else {
+    clear_has_message_value();
+    message_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Variant.message_value)
+}
+
+// optional string fourcc_value = 8;
+inline bool Variant::has_fourcc_value() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void Variant::set_has_fourcc_value() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void Variant::clear_has_fourcc_value() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void Variant::clear_fourcc_value() {
+  if (fourcc_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    fourcc_value_->clear();
+  }
+  clear_has_fourcc_value();
+}
+inline const ::std::string& Variant::fourcc_value() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Variant.fourcc_value)
+  return *fourcc_value_;
+}
+inline void Variant::set_fourcc_value(const ::std::string& value) {
+  set_has_fourcc_value();
+  if (fourcc_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    fourcc_value_ = new ::std::string;
+  }
+  fourcc_value_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.Variant.fourcc_value)
+}
+inline void Variant::set_fourcc_value(const char* value) {
+  set_has_fourcc_value();
+  if (fourcc_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    fourcc_value_ = new ::std::string;
+  }
+  fourcc_value_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.Variant.fourcc_value)
+}
+inline void Variant::set_fourcc_value(const char* value, size_t size) {
+  set_has_fourcc_value();
+  if (fourcc_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    fourcc_value_ = new ::std::string;
+  }
+  fourcc_value_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Variant.fourcc_value)
+}
+inline ::std::string* Variant::mutable_fourcc_value() {
+  set_has_fourcc_value();
+  if (fourcc_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    fourcc_value_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Variant.fourcc_value)
+  return fourcc_value_;
+}
+inline ::std::string* Variant::release_fourcc_value() {
+  clear_has_fourcc_value();
+  if (fourcc_value_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = fourcc_value_;
+    fourcc_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Variant::set_allocated_fourcc_value(::std::string* fourcc_value) {
+  if (fourcc_value_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete fourcc_value_;
+  }
+  if (fourcc_value) {
+    set_has_fourcc_value();
+    fourcc_value_ = fourcc_value;
+  } else {
+    clear_has_fourcc_value();
+    fourcc_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Variant.fourcc_value)
+}
+
+// optional uint64 uint_value = 9;
+inline bool Variant::has_uint_value() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void Variant::set_has_uint_value() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void Variant::clear_has_uint_value() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void Variant::clear_uint_value() {
+  uint_value_ = GOOGLE_ULONGLONG(0);
+  clear_has_uint_value();
+}
+inline ::google::protobuf::uint64 Variant::uint_value() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Variant.uint_value)
+  return uint_value_;
+}
+inline void Variant::set_uint_value(::google::protobuf::uint64 value) {
+  set_has_uint_value();
+  uint_value_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Variant.uint_value)
+}
+
+// optional .bgs.protocol.EntityId entity_id_value = 10;
+inline bool Variant::has_entity_id_value() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void Variant::set_has_entity_id_value() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void Variant::clear_has_entity_id_value() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void Variant::clear_entity_id_value() {
+  if (entity_id_value_ != NULL) entity_id_value_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id_value();
+}
+inline const ::bgs::protocol::EntityId& Variant::entity_id_value() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Variant.entity_id_value)
+  return entity_id_value_ != NULL ? *entity_id_value_ : *default_instance_->entity_id_value_;
+}
+inline ::bgs::protocol::EntityId* Variant::mutable_entity_id_value() {
+  set_has_entity_id_value();
+  if (entity_id_value_ == NULL) entity_id_value_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Variant.entity_id_value)
+  return entity_id_value_;
+}
+inline ::bgs::protocol::EntityId* Variant::release_entity_id_value() {
+  clear_has_entity_id_value();
+  ::bgs::protocol::EntityId* temp = entity_id_value_;
+  entity_id_value_ = NULL;
+  return temp;
+}
+inline void Variant::set_allocated_entity_id_value(::bgs::protocol::EntityId* entity_id_value) {
+  delete entity_id_value_;
+  entity_id_value_ = entity_id_value;
+  if (entity_id_value) {
+    set_has_entity_id_value();
+  } else {
+    clear_has_entity_id_value();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Variant.entity_id_value)
+}
+
+// -------------------------------------------------------------------
+
+// Attribute
+
+// required string name = 1;
+inline bool Attribute::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Attribute::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Attribute::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Attribute::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& Attribute::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Attribute.name)
+  return *name_;
+}
+inline void Attribute::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.Attribute.name)
+}
+inline void Attribute::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.Attribute.name)
+}
+inline void Attribute::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Attribute.name)
+}
+inline ::std::string* Attribute::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Attribute.name)
+  return name_;
+}
+inline ::std::string* Attribute::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Attribute::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Attribute.name)
+}
+
+// required .bgs.protocol.Variant value = 2;
+inline bool Attribute::has_value() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Attribute::set_has_value() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Attribute::clear_has_value() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Attribute::clear_value() {
+  if (value_ != NULL) value_->::bgs::protocol::Variant::Clear();
+  clear_has_value();
+}
+inline const ::bgs::protocol::Variant& Attribute::value() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Attribute.value)
+  return value_ != NULL ? *value_ : *default_instance_->value_;
+}
+inline ::bgs::protocol::Variant* Attribute::mutable_value() {
+  set_has_value();
+  if (value_ == NULL) value_ = new ::bgs::protocol::Variant;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Attribute.value)
+  return value_;
+}
+inline ::bgs::protocol::Variant* Attribute::release_value() {
+  clear_has_value();
+  ::bgs::protocol::Variant* temp = value_;
+  value_ = NULL;
+  return temp;
+}
+inline void Attribute::set_allocated_value(::bgs::protocol::Variant* value) {
+  delete value_;
+  value_ = value;
+  if (value) {
+    set_has_value();
+  } else {
+    clear_has_value();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Attribute.value)
+}
+
+// -------------------------------------------------------------------
+
+// AttributeFilter
+
+// required .bgs.protocol.AttributeFilter.Operation op = 1;
+inline bool AttributeFilter::has_op() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AttributeFilter::set_has_op() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AttributeFilter::clear_has_op() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AttributeFilter::clear_op() {
+  op_ = 0;
+  clear_has_op();
+}
+inline ::bgs::protocol::AttributeFilter_Operation AttributeFilter::op() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.AttributeFilter.op)
+  return static_cast< ::bgs::protocol::AttributeFilter_Operation >(op_);
+}
+inline void AttributeFilter::set_op(::bgs::protocol::AttributeFilter_Operation value) {
+  assert(::bgs::protocol::AttributeFilter_Operation_IsValid(value));
+  set_has_op();
+  op_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.AttributeFilter.op)
+}
+
+// repeated .bgs.protocol.Attribute attribute = 2;
+inline int AttributeFilter::attribute_size() const {
+  return attribute_.size();
+}
+inline void AttributeFilter::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::Attribute& AttributeFilter::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.AttributeFilter.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::Attribute* AttributeFilter::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.AttributeFilter.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* AttributeFilter::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.AttributeFilter.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+AttributeFilter::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.AttributeFilter.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+AttributeFilter::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.AttributeFilter.attribute)
+  return &attribute_;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::bgs::protocol::AttributeFilter_Operation> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::AttributeFilter_Operation>() {
+  return ::bgs::protocol::AttributeFilter_Operation_descriptor();
+}
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_attribute_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/authentication_service.pb.cc b/src/server/proto/Client/authentication_service.pb.cc
new file mode 100644
index 00000000000..30998e348c7
--- /dev/null
+++ b/src/server/proto/Client/authentication_service.pb.cc
@@ -0,0 +1,7731 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: authentication_service.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "authentication_service.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+#include "BattlenetRpcErrorCodes.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace authentication {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* ModuleLoadRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ModuleLoadRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ModuleNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ModuleNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ModuleMessageRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ModuleMessageRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* LogonRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  LogonRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* LogonResult_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  LogonResult_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GenerateSSOTokenRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GenerateSSOTokenRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GenerateSSOTokenResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GenerateSSOTokenResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* LogonUpdateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  LogonUpdateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* LogonQueueUpdateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  LogonQueueUpdateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountSettingsNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountSettingsNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ServerStateChangeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ServerStateChangeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* VersionInfo_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  VersionInfo_reflection_ = NULL;
+const ::google::protobuf::Descriptor* VersionInfoNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  VersionInfoNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MemModuleLoadRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemModuleLoadRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MemModuleLoadResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemModuleLoadResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SelectGameAccountRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SelectGameAccountRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameAccountSelectedRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameAccountSelectedRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GenerateWebCredentialsRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GenerateWebCredentialsRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GenerateWebCredentialsResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GenerateWebCredentialsResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* VerifyWebCredentialsRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  VerifyWebCredentialsRequest_reflection_ = NULL;
+const ::google::protobuf::ServiceDescriptor* AuthenticationListener_descriptor_ = NULL;
+const ::google::protobuf::ServiceDescriptor* AuthenticationService_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_authentication_5fservice_2eproto() {
+  protobuf_AddDesc_authentication_5fservice_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "authentication_service.proto");
+  GOOGLE_CHECK(file != NULL);
+  ModuleLoadRequest_descriptor_ = file->message_type(0);
+  static const int ModuleLoadRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleLoadRequest, module_handle_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleLoadRequest, message_),
+  };
+  ModuleLoadRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ModuleLoadRequest_descriptor_,
+      ModuleLoadRequest::default_instance_,
+      ModuleLoadRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleLoadRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleLoadRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ModuleLoadRequest));
+  ModuleNotification_descriptor_ = file->message_type(1);
+  static const int ModuleNotification_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleNotification, module_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleNotification, result_),
+  };
+  ModuleNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ModuleNotification_descriptor_,
+      ModuleNotification::default_instance_,
+      ModuleNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ModuleNotification));
+  ModuleMessageRequest_descriptor_ = file->message_type(2);
+  static const int ModuleMessageRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleMessageRequest, module_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleMessageRequest, message_),
+  };
+  ModuleMessageRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ModuleMessageRequest_descriptor_,
+      ModuleMessageRequest::default_instance_,
+      ModuleMessageRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleMessageRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ModuleMessageRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ModuleMessageRequest));
+  LogonRequest_descriptor_ = file->message_type(3);
+  static const int LogonRequest_offsets_[14] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, platform_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, locale_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, email_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, version_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, application_version_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, public_computer_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, sso_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, disconnect_on_cookie_fail_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, allow_logon_queue_notifications_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, web_client_verification_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, cached_web_credentials_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, enable_cookie_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, user_agent_),
+  };
+  LogonRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      LogonRequest_descriptor_,
+      LogonRequest::default_instance_,
+      LogonRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(LogonRequest));
+  LogonResult_descriptor_ = file->message_type(4);
+  static const int LogonResult_offsets_[10] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, error_code_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, game_account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, email_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, available_region_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, connected_region_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, battle_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, geoip_country_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, session_key_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, restricted_mode_),
+  };
+  LogonResult_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      LogonResult_descriptor_,
+      LogonResult::default_instance_,
+      LogonResult_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonResult, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(LogonResult));
+  GenerateSSOTokenRequest_descriptor_ = file->message_type(5);
+  static const int GenerateSSOTokenRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateSSOTokenRequest, program_),
+  };
+  GenerateSSOTokenRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GenerateSSOTokenRequest_descriptor_,
+      GenerateSSOTokenRequest::default_instance_,
+      GenerateSSOTokenRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateSSOTokenRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateSSOTokenRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GenerateSSOTokenRequest));
+  GenerateSSOTokenResponse_descriptor_ = file->message_type(6);
+  static const int GenerateSSOTokenResponse_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateSSOTokenResponse, sso_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateSSOTokenResponse, sso_secret_),
+  };
+  GenerateSSOTokenResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GenerateSSOTokenResponse_descriptor_,
+      GenerateSSOTokenResponse::default_instance_,
+      GenerateSSOTokenResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateSSOTokenResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateSSOTokenResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GenerateSSOTokenResponse));
+  LogonUpdateRequest_descriptor_ = file->message_type(7);
+  static const int LogonUpdateRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonUpdateRequest, error_code_),
+  };
+  LogonUpdateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      LogonUpdateRequest_descriptor_,
+      LogonUpdateRequest::default_instance_,
+      LogonUpdateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonUpdateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonUpdateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(LogonUpdateRequest));
+  LogonQueueUpdateRequest_descriptor_ = file->message_type(8);
+  static const int LogonQueueUpdateRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonQueueUpdateRequest, position_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonQueueUpdateRequest, estimated_time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonQueueUpdateRequest, eta_deviation_in_sec_),
+  };
+  LogonQueueUpdateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      LogonQueueUpdateRequest_descriptor_,
+      LogonQueueUpdateRequest::default_instance_,
+      LogonQueueUpdateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonQueueUpdateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LogonQueueUpdateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(LogonQueueUpdateRequest));
+  AccountSettingsNotification_descriptor_ = file->message_type(9);
+  static const int AccountSettingsNotification_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountSettingsNotification, licenses_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountSettingsNotification, is_using_rid_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountSettingsNotification, is_playing_from_igr_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountSettingsNotification, can_receive_voice_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountSettingsNotification, can_send_voice_),
+  };
+  AccountSettingsNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountSettingsNotification_descriptor_,
+      AccountSettingsNotification::default_instance_,
+      AccountSettingsNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountSettingsNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountSettingsNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountSettingsNotification));
+  ServerStateChangeRequest_descriptor_ = file->message_type(10);
+  static const int ServerStateChangeRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerStateChangeRequest, state_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerStateChangeRequest, event_time_),
+  };
+  ServerStateChangeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ServerStateChangeRequest_descriptor_,
+      ServerStateChangeRequest::default_instance_,
+      ServerStateChangeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerStateChangeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerStateChangeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ServerStateChangeRequest));
+  VersionInfo_descriptor_ = file->message_type(11);
+  static const int VersionInfo_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfo, number_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfo, patch_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfo, is_optional_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfo, kick_time_),
+  };
+  VersionInfo_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      VersionInfo_descriptor_,
+      VersionInfo::default_instance_,
+      VersionInfo_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfo, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfo, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(VersionInfo));
+  VersionInfoNotification_descriptor_ = file->message_type(12);
+  static const int VersionInfoNotification_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfoNotification, version_info_),
+  };
+  VersionInfoNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      VersionInfoNotification_descriptor_,
+      VersionInfoNotification::default_instance_,
+      VersionInfoNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfoNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VersionInfoNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(VersionInfoNotification));
+  MemModuleLoadRequest_descriptor_ = file->message_type(13);
+  static const int MemModuleLoadRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemModuleLoadRequest, handle_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemModuleLoadRequest, key_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemModuleLoadRequest, input_),
+  };
+  MemModuleLoadRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemModuleLoadRequest_descriptor_,
+      MemModuleLoadRequest::default_instance_,
+      MemModuleLoadRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemModuleLoadRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemModuleLoadRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemModuleLoadRequest));
+  MemModuleLoadResponse_descriptor_ = file->message_type(14);
+  static const int MemModuleLoadResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemModuleLoadResponse, data_),
+  };
+  MemModuleLoadResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemModuleLoadResponse_descriptor_,
+      MemModuleLoadResponse::default_instance_,
+      MemModuleLoadResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemModuleLoadResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemModuleLoadResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemModuleLoadResponse));
+  SelectGameAccountRequest_descriptor_ = file->message_type(15);
+  static const int SelectGameAccountRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectGameAccountRequest, game_account_id_),
+  };
+  SelectGameAccountRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SelectGameAccountRequest_descriptor_,
+      SelectGameAccountRequest::default_instance_,
+      SelectGameAccountRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectGameAccountRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectGameAccountRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SelectGameAccountRequest));
+  GameAccountSelectedRequest_descriptor_ = file->message_type(16);
+  static const int GameAccountSelectedRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSelectedRequest, result_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSelectedRequest, game_account_id_),
+  };
+  GameAccountSelectedRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameAccountSelectedRequest_descriptor_,
+      GameAccountSelectedRequest::default_instance_,
+      GameAccountSelectedRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSelectedRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountSelectedRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameAccountSelectedRequest));
+  GenerateWebCredentialsRequest_descriptor_ = file->message_type(17);
+  static const int GenerateWebCredentialsRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateWebCredentialsRequest, program_),
+  };
+  GenerateWebCredentialsRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GenerateWebCredentialsRequest_descriptor_,
+      GenerateWebCredentialsRequest::default_instance_,
+      GenerateWebCredentialsRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateWebCredentialsRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateWebCredentialsRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GenerateWebCredentialsRequest));
+  GenerateWebCredentialsResponse_descriptor_ = file->message_type(18);
+  static const int GenerateWebCredentialsResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateWebCredentialsResponse, web_credentials_),
+  };
+  GenerateWebCredentialsResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GenerateWebCredentialsResponse_descriptor_,
+      GenerateWebCredentialsResponse::default_instance_,
+      GenerateWebCredentialsResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateWebCredentialsResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenerateWebCredentialsResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GenerateWebCredentialsResponse));
+  VerifyWebCredentialsRequest_descriptor_ = file->message_type(19);
+  static const int VerifyWebCredentialsRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VerifyWebCredentialsRequest, web_credentials_),
+  };
+  VerifyWebCredentialsRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      VerifyWebCredentialsRequest_descriptor_,
+      VerifyWebCredentialsRequest::default_instance_,
+      VerifyWebCredentialsRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VerifyWebCredentialsRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(VerifyWebCredentialsRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(VerifyWebCredentialsRequest));
+  AuthenticationListener_descriptor_ = file->service(0);
+  AuthenticationService_descriptor_ = file->service(1);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_authentication_5fservice_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ModuleLoadRequest_descriptor_, &ModuleLoadRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ModuleNotification_descriptor_, &ModuleNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ModuleMessageRequest_descriptor_, &ModuleMessageRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    LogonRequest_descriptor_, &LogonRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    LogonResult_descriptor_, &LogonResult::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GenerateSSOTokenRequest_descriptor_, &GenerateSSOTokenRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GenerateSSOTokenResponse_descriptor_, &GenerateSSOTokenResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    LogonUpdateRequest_descriptor_, &LogonUpdateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    LogonQueueUpdateRequest_descriptor_, &LogonQueueUpdateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountSettingsNotification_descriptor_, &AccountSettingsNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ServerStateChangeRequest_descriptor_, &ServerStateChangeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    VersionInfo_descriptor_, &VersionInfo::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    VersionInfoNotification_descriptor_, &VersionInfoNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemModuleLoadRequest_descriptor_, &MemModuleLoadRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemModuleLoadResponse_descriptor_, &MemModuleLoadResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SelectGameAccountRequest_descriptor_, &SelectGameAccountRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameAccountSelectedRequest_descriptor_, &GameAccountSelectedRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GenerateWebCredentialsRequest_descriptor_, &GenerateWebCredentialsRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GenerateWebCredentialsResponse_descriptor_, &GenerateWebCredentialsResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    VerifyWebCredentialsRequest_descriptor_, &VerifyWebCredentialsRequest::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_authentication_5fservice_2eproto() {
+  delete ModuleLoadRequest::default_instance_;
+  delete ModuleLoadRequest_reflection_;
+  delete ModuleNotification::default_instance_;
+  delete ModuleNotification_reflection_;
+  delete ModuleMessageRequest::default_instance_;
+  delete ModuleMessageRequest_reflection_;
+  delete LogonRequest::default_instance_;
+  delete LogonRequest_reflection_;
+  delete LogonResult::default_instance_;
+  delete LogonResult_reflection_;
+  delete GenerateSSOTokenRequest::default_instance_;
+  delete GenerateSSOTokenRequest_reflection_;
+  delete GenerateSSOTokenResponse::default_instance_;
+  delete GenerateSSOTokenResponse_reflection_;
+  delete LogonUpdateRequest::default_instance_;
+  delete LogonUpdateRequest_reflection_;
+  delete LogonQueueUpdateRequest::default_instance_;
+  delete LogonQueueUpdateRequest_reflection_;
+  delete AccountSettingsNotification::default_instance_;
+  delete AccountSettingsNotification_reflection_;
+  delete ServerStateChangeRequest::default_instance_;
+  delete ServerStateChangeRequest_reflection_;
+  delete VersionInfo::default_instance_;
+  delete VersionInfo_reflection_;
+  delete VersionInfoNotification::default_instance_;
+  delete VersionInfoNotification_reflection_;
+  delete MemModuleLoadRequest::default_instance_;
+  delete MemModuleLoadRequest_reflection_;
+  delete MemModuleLoadResponse::default_instance_;
+  delete MemModuleLoadResponse_reflection_;
+  delete SelectGameAccountRequest::default_instance_;
+  delete SelectGameAccountRequest_reflection_;
+  delete GameAccountSelectedRequest::default_instance_;
+  delete GameAccountSelectedRequest_reflection_;
+  delete GenerateWebCredentialsRequest::default_instance_;
+  delete GenerateWebCredentialsRequest_reflection_;
+  delete GenerateWebCredentialsResponse::default_instance_;
+  delete GenerateWebCredentialsResponse_reflection_;
+  delete VerifyWebCredentialsRequest::default_instance_;
+  delete VerifyWebCredentialsRequest_reflection_;
+}
+
+void protobuf_AddDesc_authentication_5fservice_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::account::v1::protobuf_AddDesc_account_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_content_5fhandle_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\034authentication_service.proto\022\036bgs.prot"
+    "ocol.authentication.v1\032\023account_types.pr"
+    "oto\032\032content_handle_types.proto\032\022entity_"
+    "types.proto\032\017rpc_types.proto\"X\n\021ModuleLo"
+    "adRequest\0222\n\rmodule_handle\030\001 \002(\0132\033.bgs.p"
+    "rotocol.ContentHandle\022\017\n\007message\030\002 \001(\014\"7"
+    "\n\022ModuleNotification\022\021\n\tmodule_id\030\002 \001(\005\022"
+    "\016\n\006result\030\003 \001(\r\":\n\024ModuleMessageRequest\022"
+    "\021\n\tmodule_id\030\001 \002(\005\022\017\n\007message\030\002 \001(\014\"\372\002\n\014"
+    "LogonRequest\022\017\n\007program\030\001 \001(\t\022\020\n\010platfor"
+    "m\030\002 \001(\t\022\016\n\006locale\030\003 \001(\t\022\r\n\005email\030\004 \001(\t\022\017"
+    "\n\007version\030\005 \001(\t\022\033\n\023application_version\030\006"
+    " \001(\005\022\027\n\017public_computer\030\007 \001(\010\022\016\n\006sso_id\030"
+    "\010 \001(\014\022(\n\031disconnect_on_cookie_fail\030\t \001(\010"
+    ":\005false\022.\n\037allow_logon_queue_notificatio"
+    "ns\030\n \001(\010:\005false\022&\n\027web_client_verificati"
+    "on\030\013 \001(\010:\005false\022\036\n\026cached_web_credential"
+    "s\030\014 \001(\014\022\033\n\renable_cookie\030\r \001(\010:\004true\022\022\n\n"
+    "user_agent\030\016 \001(\t\"\232\002\n\013LogonResult\022\022\n\nerro"
+    "r_code\030\001 \002(\r\022*\n\naccount_id\030\002 \001(\0132\026.bgs.p"
+    "rotocol.EntityId\022/\n\017game_account_id\030\003 \003("
+    "\0132\026.bgs.protocol.EntityId\022\r\n\005email\030\004 \001(\t"
+    "\022\030\n\020available_region\030\005 \003(\r\022\030\n\020connected_"
+    "region\030\006 \001(\r\022\022\n\nbattle_tag\030\007 \001(\t\022\025\n\rgeoi"
+    "p_country\030\010 \001(\t\022\023\n\013session_key\030\t \001(\014\022\027\n\017"
+    "restricted_mode\030\n \001(\010\"*\n\027GenerateSSOToke"
+    "nRequest\022\017\n\007program\030\001 \001(\007\">\n\030GenerateSSO"
+    "TokenResponse\022\016\n\006sso_id\030\001 \001(\014\022\022\n\nsso_sec"
+    "ret\030\002 \001(\014\"(\n\022LogonUpdateRequest\022\022\n\nerror"
+    "_code\030\001 \002(\r\"a\n\027LogonQueueUpdateRequest\022\020"
+    "\n\010position\030\001 \002(\r\022\026\n\016estimated_time\030\002 \002(\004"
+    "\022\034\n\024eta_deviation_in_sec\030\003 \002(\004\"\276\001\n\033Accou"
+    "ntSettingsNotification\0229\n\010licenses\030\001 \003(\013"
+    "2\'.bgs.protocol.account.v1.AccountLicens"
+    "e\022\024\n\014is_using_rid\030\002 \001(\010\022\033\n\023is_playing_fr"
+    "om_igr\030\003 \001(\010\022\031\n\021can_receive_voice\030\004 \001(\010\022"
+    "\026\n\016can_send_voice\030\005 \001(\010\"=\n\030ServerStateCh"
+    "angeRequest\022\r\n\005state\030\001 \002(\r\022\022\n\nevent_time"
+    "\030\002 \002(\004\"T\n\013VersionInfo\022\016\n\006number\030\001 \001(\r\022\r\n"
+    "\005patch\030\002 \001(\t\022\023\n\013is_optional\030\003 \001(\010\022\021\n\tkic"
+    "k_time\030\004 \001(\004\"\\\n\027VersionInfoNotification\022"
+    "A\n\014version_info\030\001 \001(\0132+.bgs.protocol.aut"
+    "hentication.v1.VersionInfo\"_\n\024MemModuleL"
+    "oadRequest\022+\n\006handle\030\001 \002(\0132\033.bgs.protoco"
+    "l.ContentHandle\022\013\n\003key\030\002 \002(\014\022\r\n\005input\030\003 "
+    "\002(\014\"%\n\025MemModuleLoadResponse\022\014\n\004data\030\001 \002"
+    "(\014\"K\n\030SelectGameAccountRequest\022/\n\017game_a"
+    "ccount_id\030\001 \002(\0132\026.bgs.protocol.EntityId\""
+    "]\n\032GameAccountSelectedRequest\022\016\n\006result\030"
+    "\001 \002(\r\022/\n\017game_account_id\030\002 \001(\0132\026.bgs.pro"
+    "tocol.EntityId\"0\n\035GenerateWebCredentials"
+    "Request\022\017\n\007program\030\001 \001(\007\"9\n\036GenerateWebC"
+    "redentialsResponse\022\027\n\017web_credentials\030\001 "
+    "\001(\014\"6\n\033VerifyWebCredentialsRequest\022\027\n\017we"
+    "b_credentials\030\001 \001(\0142\202\t\n\026AuthenticationLi"
+    "stener\022e\n\014OnModuleLoad\0221.bgs.protocol.au"
+    "thentication.v1.ModuleLoadRequest\032\031.bgs."
+    "protocol.NO_RESPONSE\"\007\210\002\001\200\265\030\001\022f\n\017OnModul"
+    "eMessage\0224.bgs.protocol.authentication.v"
+    "1.ModuleMessageRequest\032\024.bgs.protocol.No"
+    "Data\"\007\210\002\001\200\265\030\002\022p\n\023OnServerStateChange\0228.b"
+    "gs.protocol.authentication.v1.ServerStat"
+    "eChangeRequest\032\031.bgs.protocol.NO_RESPONS"
+    "E\"\004\200\265\030\004\022_\n\017OnLogonComplete\022+.bgs.protoco"
+    "l.authentication.v1.LogonResult\032\031.bgs.pr"
+    "otocol.NO_RESPONSE\"\004\200\265\030\005\022\204\001\n\017OnMemModule"
+    "Load\0224.bgs.protocol.authentication.v1.Me"
+    "mModuleLoadRequest\0325.bgs.protocol.authen"
+    "tication.v1.MemModuleLoadResponse\"\004\200\265\030\006\022"
+    "d\n\rOnLogonUpdate\0222.bgs.protocol.authenti"
+    "cation.v1.LogonUpdateRequest\032\031.bgs.proto"
+    "col.NO_RESPONSE\"\004\200\265\030\n\022p\n\024OnVersionInfoUp"
+    "dated\0227.bgs.protocol.authentication.v1.V"
+    "ersionInfoNotification\032\031.bgs.protocol.NO"
+    "_RESPONSE\"\004\200\265\030\013\022n\n\022OnLogonQueueUpdate\0227."
+    "bgs.protocol.authentication.v1.LogonQueu"
+    "eUpdateRequest\032\031.bgs.protocol.NO_RESPONS"
+    "E\"\004\200\265\030\014\022H\n\017OnLogonQueueEnd\022\024.bgs.protoco"
+    "l.NoData\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030"
+    "\r\022w\n\025OnGameAccountSelected\022:.bgs.protoco"
+    "l.authentication.v1.GameAccountSelectedR"
+    "equest\032\031.bgs.protocol.NO_RESPONSE\"\007\210\002\001\200\265"
+    "\030\016\0324\312>1bnet.protocol.authentication.Auth"
+    "enticationClient2\315\007\n\025AuthenticationServi"
+    "ce\022Q\n\005Logon\022,.bgs.protocol.authenticatio"
+    "n.v1.LogonRequest\032\024.bgs.protocol.NoData\""
+    "\004\200\265\030\001\022a\n\014ModuleNotify\0222.bgs.protocol.aut"
+    "hentication.v1.ModuleNotification\032\024.bgs."
+    "protocol.NoData\"\007\210\002\001\200\265\030\002\022d\n\rModuleMessag"
+    "e\0224.bgs.protocol.authentication.v1.Modul"
+    "eMessageRequest\032\024.bgs.protocol.NoData\"\007\210"
+    "\002\001\200\265\030\003\022U\n\034SelectGameAccount_DEPRECATED\022\026"
+    ".bgs.protocol.EntityId\032\024.bgs.protocol.No"
+    "Data\"\007\210\002\001\200\265\030\004\022\213\001\n\020GenerateSSOToken\0227.bgs"
+    ".protocol.authentication.v1.GenerateSSOT"
+    "okenRequest\0328.bgs.protocol.authenticatio"
+    "n.v1.GenerateSSOTokenResponse\"\004\200\265\030\005\022l\n\021S"
+    "electGameAccount\0228.bgs.protocol.authenti"
+    "cation.v1.SelectGameAccountRequest\032\024.bgs"
+    ".protocol.NoData\"\007\210\002\001\200\265\030\006\022o\n\024VerifyWebCr"
+    "edentials\022;.bgs.protocol.authentication."
+    "v1.VerifyWebCredentialsRequest\032\024.bgs.pro"
+    "tocol.NoData\"\004\200\265\030\007\022\235\001\n\026GenerateWebCreden"
+    "tials\022=.bgs.protocol.authentication.v1.G"
+    "enerateWebCredentialsRequest\032>.bgs.proto"
+    "col.authentication.v1.GenerateWebCredent"
+    "ialsResponse\"\004\200\265\030\010\0324\312>1bnet.protocol.aut"
+    "hentication.AuthenticationServerB\005H\001\200\001\000", 4319);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "authentication_service.proto", &protobuf_RegisterTypes);
+  ModuleLoadRequest::default_instance_ = new ModuleLoadRequest();
+  ModuleNotification::default_instance_ = new ModuleNotification();
+  ModuleMessageRequest::default_instance_ = new ModuleMessageRequest();
+  LogonRequest::default_instance_ = new LogonRequest();
+  LogonResult::default_instance_ = new LogonResult();
+  GenerateSSOTokenRequest::default_instance_ = new GenerateSSOTokenRequest();
+  GenerateSSOTokenResponse::default_instance_ = new GenerateSSOTokenResponse();
+  LogonUpdateRequest::default_instance_ = new LogonUpdateRequest();
+  LogonQueueUpdateRequest::default_instance_ = new LogonQueueUpdateRequest();
+  AccountSettingsNotification::default_instance_ = new AccountSettingsNotification();
+  ServerStateChangeRequest::default_instance_ = new ServerStateChangeRequest();
+  VersionInfo::default_instance_ = new VersionInfo();
+  VersionInfoNotification::default_instance_ = new VersionInfoNotification();
+  MemModuleLoadRequest::default_instance_ = new MemModuleLoadRequest();
+  MemModuleLoadResponse::default_instance_ = new MemModuleLoadResponse();
+  SelectGameAccountRequest::default_instance_ = new SelectGameAccountRequest();
+  GameAccountSelectedRequest::default_instance_ = new GameAccountSelectedRequest();
+  GenerateWebCredentialsRequest::default_instance_ = new GenerateWebCredentialsRequest();
+  GenerateWebCredentialsResponse::default_instance_ = new GenerateWebCredentialsResponse();
+  VerifyWebCredentialsRequest::default_instance_ = new VerifyWebCredentialsRequest();
+  ModuleLoadRequest::default_instance_->InitAsDefaultInstance();
+  ModuleNotification::default_instance_->InitAsDefaultInstance();
+  ModuleMessageRequest::default_instance_->InitAsDefaultInstance();
+  LogonRequest::default_instance_->InitAsDefaultInstance();
+  LogonResult::default_instance_->InitAsDefaultInstance();
+  GenerateSSOTokenRequest::default_instance_->InitAsDefaultInstance();
+  GenerateSSOTokenResponse::default_instance_->InitAsDefaultInstance();
+  LogonUpdateRequest::default_instance_->InitAsDefaultInstance();
+  LogonQueueUpdateRequest::default_instance_->InitAsDefaultInstance();
+  AccountSettingsNotification::default_instance_->InitAsDefaultInstance();
+  ServerStateChangeRequest::default_instance_->InitAsDefaultInstance();
+  VersionInfo::default_instance_->InitAsDefaultInstance();
+  VersionInfoNotification::default_instance_->InitAsDefaultInstance();
+  MemModuleLoadRequest::default_instance_->InitAsDefaultInstance();
+  MemModuleLoadResponse::default_instance_->InitAsDefaultInstance();
+  SelectGameAccountRequest::default_instance_->InitAsDefaultInstance();
+  GameAccountSelectedRequest::default_instance_->InitAsDefaultInstance();
+  GenerateWebCredentialsRequest::default_instance_->InitAsDefaultInstance();
+  GenerateWebCredentialsResponse::default_instance_->InitAsDefaultInstance();
+  VerifyWebCredentialsRequest::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_authentication_5fservice_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_authentication_5fservice_2eproto {
+  StaticDescriptorInitializer_authentication_5fservice_2eproto() {
+    protobuf_AddDesc_authentication_5fservice_2eproto();
+  }
+} static_descriptor_initializer_authentication_5fservice_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ModuleLoadRequest::kModuleHandleFieldNumber;
+const int ModuleLoadRequest::kMessageFieldNumber;
+#endif  // !_MSC_VER
+
+ModuleLoadRequest::ModuleLoadRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.ModuleLoadRequest)
+}
+
+void ModuleLoadRequest::InitAsDefaultInstance() {
+  module_handle_ = const_cast< ::bgs::protocol::ContentHandle*>(&::bgs::protocol::ContentHandle::default_instance());
+}
+
+ModuleLoadRequest::ModuleLoadRequest(const ModuleLoadRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.ModuleLoadRequest)
+}
+
+void ModuleLoadRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  module_handle_ = NULL;
+  message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ModuleLoadRequest::~ModuleLoadRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.ModuleLoadRequest)
+  SharedDtor();
+}
+
+void ModuleLoadRequest::SharedDtor() {
+  if (message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete message_;
+  }
+  if (this != default_instance_) {
+    delete module_handle_;
+  }
+}
+
+void ModuleLoadRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ModuleLoadRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ModuleLoadRequest_descriptor_;
+}
+
+const ModuleLoadRequest& ModuleLoadRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ModuleLoadRequest* ModuleLoadRequest::default_instance_ = NULL;
+
+ModuleLoadRequest* ModuleLoadRequest::New() const {
+  return new ModuleLoadRequest;
+}
+
+void ModuleLoadRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_module_handle()) {
+      if (module_handle_ != NULL) module_handle_->::bgs::protocol::ContentHandle::Clear();
+    }
+    if (has_message()) {
+      if (message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        message_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ModuleLoadRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.ModuleLoadRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.ContentHandle module_handle = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_module_handle()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_message;
+        break;
+      }
+
+      // optional bytes message = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_message:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_message()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.ModuleLoadRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.ModuleLoadRequest)
+  return false;
+#undef DO_
+}
+
+void ModuleLoadRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.ModuleLoadRequest)
+  // required .bgs.protocol.ContentHandle module_handle = 1;
+  if (has_module_handle()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->module_handle(), output);
+  }
+
+  // optional bytes message = 2;
+  if (has_message()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->message(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.ModuleLoadRequest)
+}
+
+::google::protobuf::uint8* ModuleLoadRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.ModuleLoadRequest)
+  // required .bgs.protocol.ContentHandle module_handle = 1;
+  if (has_module_handle()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->module_handle(), target);
+  }
+
+  // optional bytes message = 2;
+  if (has_message()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        2, this->message(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.ModuleLoadRequest)
+  return target;
+}
+
+int ModuleLoadRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.ContentHandle module_handle = 1;
+    if (has_module_handle()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->module_handle());
+    }
+
+    // optional bytes message = 2;
+    if (has_message()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->message());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ModuleLoadRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ModuleLoadRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ModuleLoadRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ModuleLoadRequest::MergeFrom(const ModuleLoadRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_module_handle()) {
+      mutable_module_handle()->::bgs::protocol::ContentHandle::MergeFrom(from.module_handle());
+    }
+    if (from.has_message()) {
+      set_message(from.message());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ModuleLoadRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ModuleLoadRequest::CopyFrom(const ModuleLoadRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ModuleLoadRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_module_handle()) {
+    if (!this->module_handle().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ModuleLoadRequest::Swap(ModuleLoadRequest* other) {
+  if (other != this) {
+    std::swap(module_handle_, other->module_handle_);
+    std::swap(message_, other->message_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ModuleLoadRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ModuleLoadRequest_descriptor_;
+  metadata.reflection = ModuleLoadRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ModuleNotification::kModuleIdFieldNumber;
+const int ModuleNotification::kResultFieldNumber;
+#endif  // !_MSC_VER
+
+ModuleNotification::ModuleNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.ModuleNotification)
+}
+
+void ModuleNotification::InitAsDefaultInstance() {
+}
+
+ModuleNotification::ModuleNotification(const ModuleNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.ModuleNotification)
+}
+
+void ModuleNotification::SharedCtor() {
+  _cached_size_ = 0;
+  module_id_ = 0;
+  result_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ModuleNotification::~ModuleNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.ModuleNotification)
+  SharedDtor();
+}
+
+void ModuleNotification::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ModuleNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ModuleNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ModuleNotification_descriptor_;
+}
+
+const ModuleNotification& ModuleNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ModuleNotification* ModuleNotification::default_instance_ = NULL;
+
+ModuleNotification* ModuleNotification::New() const {
+  return new ModuleNotification;
+}
+
+void ModuleNotification::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ModuleNotification*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(module_id_, result_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ModuleNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.ModuleNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional int32 module_id = 2;
+      case 2: {
+        if (tag == 16) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &module_id_)));
+          set_has_module_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_result;
+        break;
+      }
+
+      // optional uint32 result = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_result:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &result_)));
+          set_has_result();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.ModuleNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.ModuleNotification)
+  return false;
+#undef DO_
+}
+
+void ModuleNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.ModuleNotification)
+  // optional int32 module_id = 2;
+  if (has_module_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->module_id(), output);
+  }
+
+  // optional uint32 result = 3;
+  if (has_result()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->result(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.ModuleNotification)
+}
+
+::google::protobuf::uint8* ModuleNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.ModuleNotification)
+  // optional int32 module_id = 2;
+  if (has_module_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->module_id(), target);
+  }
+
+  // optional uint32 result = 3;
+  if (has_result()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->result(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.ModuleNotification)
+  return target;
+}
+
+int ModuleNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional int32 module_id = 2;
+    if (has_module_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->module_id());
+    }
+
+    // optional uint32 result = 3;
+    if (has_result()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->result());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ModuleNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ModuleNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ModuleNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ModuleNotification::MergeFrom(const ModuleNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_module_id()) {
+      set_module_id(from.module_id());
+    }
+    if (from.has_result()) {
+      set_result(from.result());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ModuleNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ModuleNotification::CopyFrom(const ModuleNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ModuleNotification::IsInitialized() const {
+
+  return true;
+}
+
+void ModuleNotification::Swap(ModuleNotification* other) {
+  if (other != this) {
+    std::swap(module_id_, other->module_id_);
+    std::swap(result_, other->result_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ModuleNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ModuleNotification_descriptor_;
+  metadata.reflection = ModuleNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ModuleMessageRequest::kModuleIdFieldNumber;
+const int ModuleMessageRequest::kMessageFieldNumber;
+#endif  // !_MSC_VER
+
+ModuleMessageRequest::ModuleMessageRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.ModuleMessageRequest)
+}
+
+void ModuleMessageRequest::InitAsDefaultInstance() {
+}
+
+ModuleMessageRequest::ModuleMessageRequest(const ModuleMessageRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.ModuleMessageRequest)
+}
+
+void ModuleMessageRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  module_id_ = 0;
+  message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ModuleMessageRequest::~ModuleMessageRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.ModuleMessageRequest)
+  SharedDtor();
+}
+
+void ModuleMessageRequest::SharedDtor() {
+  if (message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete message_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ModuleMessageRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ModuleMessageRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ModuleMessageRequest_descriptor_;
+}
+
+const ModuleMessageRequest& ModuleMessageRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ModuleMessageRequest* ModuleMessageRequest::default_instance_ = NULL;
+
+ModuleMessageRequest* ModuleMessageRequest::New() const {
+  return new ModuleMessageRequest;
+}
+
+void ModuleMessageRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    module_id_ = 0;
+    if (has_message()) {
+      if (message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        message_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ModuleMessageRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.ModuleMessageRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required int32 module_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &module_id_)));
+          set_has_module_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_message;
+        break;
+      }
+
+      // optional bytes message = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_message:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_message()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.ModuleMessageRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.ModuleMessageRequest)
+  return false;
+#undef DO_
+}
+
+void ModuleMessageRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.ModuleMessageRequest)
+  // required int32 module_id = 1;
+  if (has_module_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->module_id(), output);
+  }
+
+  // optional bytes message = 2;
+  if (has_message()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->message(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.ModuleMessageRequest)
+}
+
+::google::protobuf::uint8* ModuleMessageRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.ModuleMessageRequest)
+  // required int32 module_id = 1;
+  if (has_module_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->module_id(), target);
+  }
+
+  // optional bytes message = 2;
+  if (has_message()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        2, this->message(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.ModuleMessageRequest)
+  return target;
+}
+
+int ModuleMessageRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required int32 module_id = 1;
+    if (has_module_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->module_id());
+    }
+
+    // optional bytes message = 2;
+    if (has_message()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->message());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ModuleMessageRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ModuleMessageRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ModuleMessageRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ModuleMessageRequest::MergeFrom(const ModuleMessageRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_module_id()) {
+      set_module_id(from.module_id());
+    }
+    if (from.has_message()) {
+      set_message(from.message());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ModuleMessageRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ModuleMessageRequest::CopyFrom(const ModuleMessageRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ModuleMessageRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  return true;
+}
+
+void ModuleMessageRequest::Swap(ModuleMessageRequest* other) {
+  if (other != this) {
+    std::swap(module_id_, other->module_id_);
+    std::swap(message_, other->message_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ModuleMessageRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ModuleMessageRequest_descriptor_;
+  metadata.reflection = ModuleMessageRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int LogonRequest::kProgramFieldNumber;
+const int LogonRequest::kPlatformFieldNumber;
+const int LogonRequest::kLocaleFieldNumber;
+const int LogonRequest::kEmailFieldNumber;
+const int LogonRequest::kVersionFieldNumber;
+const int LogonRequest::kApplicationVersionFieldNumber;
+const int LogonRequest::kPublicComputerFieldNumber;
+const int LogonRequest::kSsoIdFieldNumber;
+const int LogonRequest::kDisconnectOnCookieFailFieldNumber;
+const int LogonRequest::kAllowLogonQueueNotificationsFieldNumber;
+const int LogonRequest::kWebClientVerificationFieldNumber;
+const int LogonRequest::kCachedWebCredentialsFieldNumber;
+const int LogonRequest::kEnableCookieFieldNumber;
+const int LogonRequest::kUserAgentFieldNumber;
+#endif  // !_MSC_VER
+
+LogonRequest::LogonRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.LogonRequest)
+}
+
+void LogonRequest::InitAsDefaultInstance() {
+}
+
+LogonRequest::LogonRequest(const LogonRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.LogonRequest)
+}
+
+void LogonRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  program_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  platform_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  locale_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  version_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  application_version_ = 0;
+  public_computer_ = false;
+  sso_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  disconnect_on_cookie_fail_ = false;
+  allow_logon_queue_notifications_ = false;
+  web_client_verification_ = false;
+  cached_web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  enable_cookie_ = true;
+  user_agent_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+LogonRequest::~LogonRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.LogonRequest)
+  SharedDtor();
+}
+
+void LogonRequest::SharedDtor() {
+  if (program_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete program_;
+  }
+  if (platform_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete platform_;
+  }
+  if (locale_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete locale_;
+  }
+  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete email_;
+  }
+  if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete version_;
+  }
+  if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete sso_id_;
+  }
+  if (cached_web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete cached_web_credentials_;
+  }
+  if (user_agent_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete user_agent_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void LogonRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* LogonRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return LogonRequest_descriptor_;
+}
+
+const LogonRequest& LogonRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+LogonRequest* LogonRequest::default_instance_ = NULL;
+
+LogonRequest* LogonRequest::New() const {
+  return new LogonRequest;
+}
+
+void LogonRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<LogonRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 255) {
+    ZR_(application_version_, public_computer_);
+    if (has_program()) {
+      if (program_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        program_->clear();
+      }
+    }
+    if (has_platform()) {
+      if (platform_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        platform_->clear();
+      }
+    }
+    if (has_locale()) {
+      if (locale_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        locale_->clear();
+      }
+    }
+    if (has_email()) {
+      if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        email_->clear();
+      }
+    }
+    if (has_version()) {
+      if (version_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        version_->clear();
+      }
+    }
+    if (has_sso_id()) {
+      if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        sso_id_->clear();
+      }
+    }
+  }
+  if (_has_bits_[8 / 32] & 16128) {
+    ZR_(disconnect_on_cookie_fail_, web_client_verification_);
+    if (has_cached_web_credentials()) {
+      if (cached_web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        cached_web_credentials_->clear();
+      }
+    }
+    enable_cookie_ = true;
+    if (has_user_agent()) {
+      if (user_agent_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        user_agent_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool LogonRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.LogonRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string program = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_program()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->program().data(), this->program().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "program");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_platform;
+        break;
+      }
+
+      // optional string platform = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_platform:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_platform()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->platform().data(), this->platform().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "platform");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_locale;
+        break;
+      }
+
+      // optional string locale = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_locale:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_locale()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->locale().data(), this->locale().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "locale");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_email;
+        break;
+      }
+
+      // optional string email = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_email:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_email()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->email().data(), this->email().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "email");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_version;
+        break;
+      }
+
+      // optional string version = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_version:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_version()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->version().data(), this->version().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "version");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_application_version;
+        break;
+      }
+
+      // optional int32 application_version = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_application_version:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &application_version_)));
+          set_has_application_version();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_public_computer;
+        break;
+      }
+
+      // optional bool public_computer = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_public_computer:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &public_computer_)));
+          set_has_public_computer();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_sso_id;
+        break;
+      }
+
+      // optional bytes sso_id = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_sso_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_sso_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(72)) goto parse_disconnect_on_cookie_fail;
+        break;
+      }
+
+      // optional bool disconnect_on_cookie_fail = 9 [default = false];
+      case 9: {
+        if (tag == 72) {
+         parse_disconnect_on_cookie_fail:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &disconnect_on_cookie_fail_)));
+          set_has_disconnect_on_cookie_fail();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(80)) goto parse_allow_logon_queue_notifications;
+        break;
+      }
+
+      // optional bool allow_logon_queue_notifications = 10 [default = false];
+      case 10: {
+        if (tag == 80) {
+         parse_allow_logon_queue_notifications:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &allow_logon_queue_notifications_)));
+          set_has_allow_logon_queue_notifications();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(88)) goto parse_web_client_verification;
+        break;
+      }
+
+      // optional bool web_client_verification = 11 [default = false];
+      case 11: {
+        if (tag == 88) {
+         parse_web_client_verification:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &web_client_verification_)));
+          set_has_web_client_verification();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(98)) goto parse_cached_web_credentials;
+        break;
+      }
+
+      // optional bytes cached_web_credentials = 12;
+      case 12: {
+        if (tag == 98) {
+         parse_cached_web_credentials:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_cached_web_credentials()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(104)) goto parse_enable_cookie;
+        break;
+      }
+
+      // optional bool enable_cookie = 13 [default = true];
+      case 13: {
+        if (tag == 104) {
+         parse_enable_cookie:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &enable_cookie_)));
+          set_has_enable_cookie();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(114)) goto parse_user_agent;
+        break;
+      }
+
+      // optional string user_agent = 14;
+      case 14: {
+        if (tag == 114) {
+         parse_user_agent:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_user_agent()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->user_agent().data(), this->user_agent().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "user_agent");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.LogonRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.LogonRequest)
+  return false;
+#undef DO_
+}
+
+void LogonRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.LogonRequest)
+  // optional string program = 1;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->program().data(), this->program().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "program");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->program(), output);
+  }
+
+  // optional string platform = 2;
+  if (has_platform()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->platform().data(), this->platform().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "platform");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->platform(), output);
+  }
+
+  // optional string locale = 3;
+  if (has_locale()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->locale().data(), this->locale().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "locale");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->locale(), output);
+  }
+
+  // optional string email = 4;
+  if (has_email()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->email().data(), this->email().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "email");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->email(), output);
+  }
+
+  // optional string version = 5;
+  if (has_version()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->version().data(), this->version().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "version");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      5, this->version(), output);
+  }
+
+  // optional int32 application_version = 6;
+  if (has_application_version()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->application_version(), output);
+  }
+
+  // optional bool public_computer = 7;
+  if (has_public_computer()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->public_computer(), output);
+  }
+
+  // optional bytes sso_id = 8;
+  if (has_sso_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      8, this->sso_id(), output);
+  }
+
+  // optional bool disconnect_on_cookie_fail = 9 [default = false];
+  if (has_disconnect_on_cookie_fail()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->disconnect_on_cookie_fail(), output);
+  }
+
+  // optional bool allow_logon_queue_notifications = 10 [default = false];
+  if (has_allow_logon_queue_notifications()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->allow_logon_queue_notifications(), output);
+  }
+
+  // optional bool web_client_verification = 11 [default = false];
+  if (has_web_client_verification()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(11, this->web_client_verification(), output);
+  }
+
+  // optional bytes cached_web_credentials = 12;
+  if (has_cached_web_credentials()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      12, this->cached_web_credentials(), output);
+  }
+
+  // optional bool enable_cookie = 13 [default = true];
+  if (has_enable_cookie()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(13, this->enable_cookie(), output);
+  }
+
+  // optional string user_agent = 14;
+  if (has_user_agent()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->user_agent().data(), this->user_agent().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "user_agent");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      14, this->user_agent(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.LogonRequest)
+}
+
+::google::protobuf::uint8* LogonRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.LogonRequest)
+  // optional string program = 1;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->program().data(), this->program().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "program");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->program(), target);
+  }
+
+  // optional string platform = 2;
+  if (has_platform()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->platform().data(), this->platform().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "platform");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->platform(), target);
+  }
+
+  // optional string locale = 3;
+  if (has_locale()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->locale().data(), this->locale().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "locale");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->locale(), target);
+  }
+
+  // optional string email = 4;
+  if (has_email()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->email().data(), this->email().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "email");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->email(), target);
+  }
+
+  // optional string version = 5;
+  if (has_version()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->version().data(), this->version().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "version");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->version(), target);
+  }
+
+  // optional int32 application_version = 6;
+  if (has_application_version()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->application_version(), target);
+  }
+
+  // optional bool public_computer = 7;
+  if (has_public_computer()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->public_computer(), target);
+  }
+
+  // optional bytes sso_id = 8;
+  if (has_sso_id()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        8, this->sso_id(), target);
+  }
+
+  // optional bool disconnect_on_cookie_fail = 9 [default = false];
+  if (has_disconnect_on_cookie_fail()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->disconnect_on_cookie_fail(), target);
+  }
+
+  // optional bool allow_logon_queue_notifications = 10 [default = false];
+  if (has_allow_logon_queue_notifications()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->allow_logon_queue_notifications(), target);
+  }
+
+  // optional bool web_client_verification = 11 [default = false];
+  if (has_web_client_verification()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(11, this->web_client_verification(), target);
+  }
+
+  // optional bytes cached_web_credentials = 12;
+  if (has_cached_web_credentials()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        12, this->cached_web_credentials(), target);
+  }
+
+  // optional bool enable_cookie = 13 [default = true];
+  if (has_enable_cookie()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(13, this->enable_cookie(), target);
+  }
+
+  // optional string user_agent = 14;
+  if (has_user_agent()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->user_agent().data(), this->user_agent().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "user_agent");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        14, this->user_agent(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.LogonRequest)
+  return target;
+}
+
+int LogonRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string program = 1;
+    if (has_program()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->program());
+    }
+
+    // optional string platform = 2;
+    if (has_platform()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->platform());
+    }
+
+    // optional string locale = 3;
+    if (has_locale()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->locale());
+    }
+
+    // optional string email = 4;
+    if (has_email()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->email());
+    }
+
+    // optional string version = 5;
+    if (has_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->version());
+    }
+
+    // optional int32 application_version = 6;
+    if (has_application_version()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->application_version());
+    }
+
+    // optional bool public_computer = 7;
+    if (has_public_computer()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bytes sso_id = 8;
+    if (has_sso_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->sso_id());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional bool disconnect_on_cookie_fail = 9 [default = false];
+    if (has_disconnect_on_cookie_fail()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool allow_logon_queue_notifications = 10 [default = false];
+    if (has_allow_logon_queue_notifications()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool web_client_verification = 11 [default = false];
+    if (has_web_client_verification()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bytes cached_web_credentials = 12;
+    if (has_cached_web_credentials()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->cached_web_credentials());
+    }
+
+    // optional bool enable_cookie = 13 [default = true];
+    if (has_enable_cookie()) {
+      total_size += 1 + 1;
+    }
+
+    // optional string user_agent = 14;
+    if (has_user_agent()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->user_agent());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void LogonRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const LogonRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const LogonRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void LogonRequest::MergeFrom(const LogonRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_platform()) {
+      set_platform(from.platform());
+    }
+    if (from.has_locale()) {
+      set_locale(from.locale());
+    }
+    if (from.has_email()) {
+      set_email(from.email());
+    }
+    if (from.has_version()) {
+      set_version(from.version());
+    }
+    if (from.has_application_version()) {
+      set_application_version(from.application_version());
+    }
+    if (from.has_public_computer()) {
+      set_public_computer(from.public_computer());
+    }
+    if (from.has_sso_id()) {
+      set_sso_id(from.sso_id());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_disconnect_on_cookie_fail()) {
+      set_disconnect_on_cookie_fail(from.disconnect_on_cookie_fail());
+    }
+    if (from.has_allow_logon_queue_notifications()) {
+      set_allow_logon_queue_notifications(from.allow_logon_queue_notifications());
+    }
+    if (from.has_web_client_verification()) {
+      set_web_client_verification(from.web_client_verification());
+    }
+    if (from.has_cached_web_credentials()) {
+      set_cached_web_credentials(from.cached_web_credentials());
+    }
+    if (from.has_enable_cookie()) {
+      set_enable_cookie(from.enable_cookie());
+    }
+    if (from.has_user_agent()) {
+      set_user_agent(from.user_agent());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void LogonRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void LogonRequest::CopyFrom(const LogonRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool LogonRequest::IsInitialized() const {
+
+  return true;
+}
+
+void LogonRequest::Swap(LogonRequest* other) {
+  if (other != this) {
+    std::swap(program_, other->program_);
+    std::swap(platform_, other->platform_);
+    std::swap(locale_, other->locale_);
+    std::swap(email_, other->email_);
+    std::swap(version_, other->version_);
+    std::swap(application_version_, other->application_version_);
+    std::swap(public_computer_, other->public_computer_);
+    std::swap(sso_id_, other->sso_id_);
+    std::swap(disconnect_on_cookie_fail_, other->disconnect_on_cookie_fail_);
+    std::swap(allow_logon_queue_notifications_, other->allow_logon_queue_notifications_);
+    std::swap(web_client_verification_, other->web_client_verification_);
+    std::swap(cached_web_credentials_, other->cached_web_credentials_);
+    std::swap(enable_cookie_, other->enable_cookie_);
+    std::swap(user_agent_, other->user_agent_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata LogonRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = LogonRequest_descriptor_;
+  metadata.reflection = LogonRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int LogonResult::kErrorCodeFieldNumber;
+const int LogonResult::kAccountIdFieldNumber;
+const int LogonResult::kGameAccountIdFieldNumber;
+const int LogonResult::kEmailFieldNumber;
+const int LogonResult::kAvailableRegionFieldNumber;
+const int LogonResult::kConnectedRegionFieldNumber;
+const int LogonResult::kBattleTagFieldNumber;
+const int LogonResult::kGeoipCountryFieldNumber;
+const int LogonResult::kSessionKeyFieldNumber;
+const int LogonResult::kRestrictedModeFieldNumber;
+#endif  // !_MSC_VER
+
+LogonResult::LogonResult()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.LogonResult)
+}
+
+void LogonResult::InitAsDefaultInstance() {
+  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+LogonResult::LogonResult(const LogonResult& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.LogonResult)
+}
+
+void LogonResult::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  error_code_ = 0u;
+  account_id_ = NULL;
+  email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  connected_region_ = 0u;
+  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  geoip_country_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  session_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  restricted_mode_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+LogonResult::~LogonResult() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.LogonResult)
+  SharedDtor();
+}
+
+void LogonResult::SharedDtor() {
+  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete email_;
+  }
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete battle_tag_;
+  }
+  if (geoip_country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete geoip_country_;
+  }
+  if (session_key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete session_key_;
+  }
+  if (this != default_instance_) {
+    delete account_id_;
+  }
+}
+
+void LogonResult::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* LogonResult::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return LogonResult_descriptor_;
+}
+
+const LogonResult& LogonResult::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+LogonResult* LogonResult::default_instance_ = NULL;
+
+LogonResult* LogonResult::New() const {
+  return new LogonResult;
+}
+
+void LogonResult::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<LogonResult*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 235) {
+    ZR_(error_code_, connected_region_);
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_email()) {
+      if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        email_->clear();
+      }
+    }
+    if (has_battle_tag()) {
+      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        battle_tag_->clear();
+      }
+    }
+    if (has_geoip_country()) {
+      if (geoip_country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        geoip_country_->clear();
+      }
+    }
+  }
+  if (_has_bits_[8 / 32] & 768) {
+    if (has_session_key()) {
+      if (session_key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        session_key_->clear();
+      }
+    }
+    restricted_mode_ = false;
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  game_account_id_.Clear();
+  available_region_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool LogonResult::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.LogonResult)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required uint32 error_code = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &error_code_)));
+          set_has_error_code();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId account_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_game_account_id;
+        break;
+      }
+
+      // repeated .bgs.protocol.EntityId game_account_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_game_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_game_account_id;
+        if (input->ExpectTag(34)) goto parse_email;
+        break;
+      }
+
+      // optional string email = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_email:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_email()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->email().data(), this->email().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "email");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_available_region;
+        break;
+      }
+
+      // repeated uint32 available_region = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_available_region:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 40, input, this->mutable_available_region())));
+        } else if (tag == 42) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_available_region())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_available_region;
+        if (input->ExpectTag(48)) goto parse_connected_region;
+        break;
+      }
+
+      // optional uint32 connected_region = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_connected_region:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &connected_region_)));
+          set_has_connected_region();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_battle_tag;
+        break;
+      }
+
+      // optional string battle_tag = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_battle_tag:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_battle_tag()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->battle_tag().data(), this->battle_tag().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "battle_tag");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_geoip_country;
+        break;
+      }
+
+      // optional string geoip_country = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_geoip_country:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_geoip_country()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->geoip_country().data(), this->geoip_country().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "geoip_country");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(74)) goto parse_session_key;
+        break;
+      }
+
+      // optional bytes session_key = 9;
+      case 9: {
+        if (tag == 74) {
+         parse_session_key:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_session_key()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(80)) goto parse_restricted_mode;
+        break;
+      }
+
+      // optional bool restricted_mode = 10;
+      case 10: {
+        if (tag == 80) {
+         parse_restricted_mode:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &restricted_mode_)));
+          set_has_restricted_mode();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.LogonResult)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.LogonResult)
+  return false;
+#undef DO_
+}
+
+void LogonResult::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.LogonResult)
+  // required uint32 error_code = 1;
+  if (has_error_code()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->error_code(), output);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 2;
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->account_id(), output);
+  }
+
+  // repeated .bgs.protocol.EntityId game_account_id = 3;
+  for (int i = 0; i < this->game_account_id_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->game_account_id(i), output);
+  }
+
+  // optional string email = 4;
+  if (has_email()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->email().data(), this->email().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "email");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->email(), output);
+  }
+
+  // repeated uint32 available_region = 5;
+  for (int i = 0; i < this->available_region_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(
+      5, this->available_region(i), output);
+  }
+
+  // optional uint32 connected_region = 6;
+  if (has_connected_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->connected_region(), output);
+  }
+
+  // optional string battle_tag = 7;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      7, this->battle_tag(), output);
+  }
+
+  // optional string geoip_country = 8;
+  if (has_geoip_country()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->geoip_country().data(), this->geoip_country().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "geoip_country");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      8, this->geoip_country(), output);
+  }
+
+  // optional bytes session_key = 9;
+  if (has_session_key()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      9, this->session_key(), output);
+  }
+
+  // optional bool restricted_mode = 10;
+  if (has_restricted_mode()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->restricted_mode(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.LogonResult)
+}
+
+::google::protobuf::uint8* LogonResult::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.LogonResult)
+  // required uint32 error_code = 1;
+  if (has_error_code()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->error_code(), target);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 2;
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->account_id(), target);
+  }
+
+  // repeated .bgs.protocol.EntityId game_account_id = 3;
+  for (int i = 0; i < this->game_account_id_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->game_account_id(i), target);
+  }
+
+  // optional string email = 4;
+  if (has_email()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->email().data(), this->email().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "email");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->email(), target);
+  }
+
+  // repeated uint32 available_region = 5;
+  for (int i = 0; i < this->available_region_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32ToArray(5, this->available_region(i), target);
+  }
+
+  // optional uint32 connected_region = 6;
+  if (has_connected_region()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->connected_region(), target);
+  }
+
+  // optional string battle_tag = 7;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        7, this->battle_tag(), target);
+  }
+
+  // optional string geoip_country = 8;
+  if (has_geoip_country()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->geoip_country().data(), this->geoip_country().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "geoip_country");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        8, this->geoip_country(), target);
+  }
+
+  // optional bytes session_key = 9;
+  if (has_session_key()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        9, this->session_key(), target);
+  }
+
+  // optional bool restricted_mode = 10;
+  if (has_restricted_mode()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->restricted_mode(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.LogonResult)
+  return target;
+}
+
+int LogonResult::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 error_code = 1;
+    if (has_error_code()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->error_code());
+    }
+
+    // optional .bgs.protocol.EntityId account_id = 2;
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+    // optional string email = 4;
+    if (has_email()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->email());
+    }
+
+    // optional uint32 connected_region = 6;
+    if (has_connected_region()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->connected_region());
+    }
+
+    // optional string battle_tag = 7;
+    if (has_battle_tag()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->battle_tag());
+    }
+
+    // optional string geoip_country = 8;
+    if (has_geoip_country()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->geoip_country());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional bytes session_key = 9;
+    if (has_session_key()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->session_key());
+    }
+
+    // optional bool restricted_mode = 10;
+    if (has_restricted_mode()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated .bgs.protocol.EntityId game_account_id = 3;
+  total_size += 1 * this->game_account_id_size();
+  for (int i = 0; i < this->game_account_id_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->game_account_id(i));
+  }
+
+  // repeated uint32 available_region = 5;
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->available_region_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->available_region(i));
+    }
+    total_size += 1 * this->available_region_size() + data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void LogonResult::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const LogonResult* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const LogonResult*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void LogonResult::MergeFrom(const LogonResult& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  game_account_id_.MergeFrom(from.game_account_id_);
+  available_region_.MergeFrom(from.available_region_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_error_code()) {
+      set_error_code(from.error_code());
+    }
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
+    }
+    if (from.has_email()) {
+      set_email(from.email());
+    }
+    if (from.has_connected_region()) {
+      set_connected_region(from.connected_region());
+    }
+    if (from.has_battle_tag()) {
+      set_battle_tag(from.battle_tag());
+    }
+    if (from.has_geoip_country()) {
+      set_geoip_country(from.geoip_country());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_session_key()) {
+      set_session_key(from.session_key());
+    }
+    if (from.has_restricted_mode()) {
+      set_restricted_mode(from.restricted_mode());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void LogonResult::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void LogonResult::CopyFrom(const LogonResult& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool LogonResult::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->game_account_id())) return false;
+  return true;
+}
+
+void LogonResult::Swap(LogonResult* other) {
+  if (other != this) {
+    std::swap(error_code_, other->error_code_);
+    std::swap(account_id_, other->account_id_);
+    game_account_id_.Swap(&other->game_account_id_);
+    std::swap(email_, other->email_);
+    available_region_.Swap(&other->available_region_);
+    std::swap(connected_region_, other->connected_region_);
+    std::swap(battle_tag_, other->battle_tag_);
+    std::swap(geoip_country_, other->geoip_country_);
+    std::swap(session_key_, other->session_key_);
+    std::swap(restricted_mode_, other->restricted_mode_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata LogonResult::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = LogonResult_descriptor_;
+  metadata.reflection = LogonResult_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GenerateSSOTokenRequest::kProgramFieldNumber;
+#endif  // !_MSC_VER
+
+GenerateSSOTokenRequest::GenerateSSOTokenRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.GenerateSSOTokenRequest)
+}
+
+void GenerateSSOTokenRequest::InitAsDefaultInstance() {
+}
+
+GenerateSSOTokenRequest::GenerateSSOTokenRequest(const GenerateSSOTokenRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.GenerateSSOTokenRequest)
+}
+
+void GenerateSSOTokenRequest::SharedCtor() {
+  _cached_size_ = 0;
+  program_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GenerateSSOTokenRequest::~GenerateSSOTokenRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.GenerateSSOTokenRequest)
+  SharedDtor();
+}
+
+void GenerateSSOTokenRequest::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GenerateSSOTokenRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GenerateSSOTokenRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GenerateSSOTokenRequest_descriptor_;
+}
+
+const GenerateSSOTokenRequest& GenerateSSOTokenRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GenerateSSOTokenRequest* GenerateSSOTokenRequest::default_instance_ = NULL;
+
+GenerateSSOTokenRequest* GenerateSSOTokenRequest::New() const {
+  return new GenerateSSOTokenRequest;
+}
+
+void GenerateSSOTokenRequest::Clear() {
+  program_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GenerateSSOTokenRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.GenerateSSOTokenRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional fixed32 program = 1;
+      case 1: {
+        if (tag == 13) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.GenerateSSOTokenRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.GenerateSSOTokenRequest)
+  return false;
+#undef DO_
+}
+
+void GenerateSSOTokenRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.GenerateSSOTokenRequest)
+  // optional fixed32 program = 1;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->program(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.GenerateSSOTokenRequest)
+}
+
+::google::protobuf::uint8* GenerateSSOTokenRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.GenerateSSOTokenRequest)
+  // optional fixed32 program = 1;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->program(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.GenerateSSOTokenRequest)
+  return target;
+}
+
+int GenerateSSOTokenRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional fixed32 program = 1;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GenerateSSOTokenRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GenerateSSOTokenRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GenerateSSOTokenRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GenerateSSOTokenRequest::MergeFrom(const GenerateSSOTokenRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GenerateSSOTokenRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GenerateSSOTokenRequest::CopyFrom(const GenerateSSOTokenRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GenerateSSOTokenRequest::IsInitialized() const {
+
+  return true;
+}
+
+void GenerateSSOTokenRequest::Swap(GenerateSSOTokenRequest* other) {
+  if (other != this) {
+    std::swap(program_, other->program_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GenerateSSOTokenRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GenerateSSOTokenRequest_descriptor_;
+  metadata.reflection = GenerateSSOTokenRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GenerateSSOTokenResponse::kSsoIdFieldNumber;
+const int GenerateSSOTokenResponse::kSsoSecretFieldNumber;
+#endif  // !_MSC_VER
+
+GenerateSSOTokenResponse::GenerateSSOTokenResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.GenerateSSOTokenResponse)
+}
+
+void GenerateSSOTokenResponse::InitAsDefaultInstance() {
+}
+
+GenerateSSOTokenResponse::GenerateSSOTokenResponse(const GenerateSSOTokenResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.GenerateSSOTokenResponse)
+}
+
+void GenerateSSOTokenResponse::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  sso_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  sso_secret_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GenerateSSOTokenResponse::~GenerateSSOTokenResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.GenerateSSOTokenResponse)
+  SharedDtor();
+}
+
+void GenerateSSOTokenResponse::SharedDtor() {
+  if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete sso_id_;
+  }
+  if (sso_secret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete sso_secret_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void GenerateSSOTokenResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GenerateSSOTokenResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GenerateSSOTokenResponse_descriptor_;
+}
+
+const GenerateSSOTokenResponse& GenerateSSOTokenResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GenerateSSOTokenResponse* GenerateSSOTokenResponse::default_instance_ = NULL;
+
+GenerateSSOTokenResponse* GenerateSSOTokenResponse::New() const {
+  return new GenerateSSOTokenResponse;
+}
+
+void GenerateSSOTokenResponse::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_sso_id()) {
+      if (sso_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        sso_id_->clear();
+      }
+    }
+    if (has_sso_secret()) {
+      if (sso_secret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        sso_secret_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GenerateSSOTokenResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.GenerateSSOTokenResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes sso_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_sso_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_sso_secret;
+        break;
+      }
+
+      // optional bytes sso_secret = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_sso_secret:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_sso_secret()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.GenerateSSOTokenResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.GenerateSSOTokenResponse)
+  return false;
+#undef DO_
+}
+
+void GenerateSSOTokenResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.GenerateSSOTokenResponse)
+  // optional bytes sso_id = 1;
+  if (has_sso_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->sso_id(), output);
+  }
+
+  // optional bytes sso_secret = 2;
+  if (has_sso_secret()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->sso_secret(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.GenerateSSOTokenResponse)
+}
+
+::google::protobuf::uint8* GenerateSSOTokenResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.GenerateSSOTokenResponse)
+  // optional bytes sso_id = 1;
+  if (has_sso_id()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        1, this->sso_id(), target);
+  }
+
+  // optional bytes sso_secret = 2;
+  if (has_sso_secret()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        2, this->sso_secret(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.GenerateSSOTokenResponse)
+  return target;
+}
+
+int GenerateSSOTokenResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes sso_id = 1;
+    if (has_sso_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->sso_id());
+    }
+
+    // optional bytes sso_secret = 2;
+    if (has_sso_secret()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->sso_secret());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GenerateSSOTokenResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GenerateSSOTokenResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GenerateSSOTokenResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GenerateSSOTokenResponse::MergeFrom(const GenerateSSOTokenResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_sso_id()) {
+      set_sso_id(from.sso_id());
+    }
+    if (from.has_sso_secret()) {
+      set_sso_secret(from.sso_secret());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GenerateSSOTokenResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GenerateSSOTokenResponse::CopyFrom(const GenerateSSOTokenResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GenerateSSOTokenResponse::IsInitialized() const {
+
+  return true;
+}
+
+void GenerateSSOTokenResponse::Swap(GenerateSSOTokenResponse* other) {
+  if (other != this) {
+    std::swap(sso_id_, other->sso_id_);
+    std::swap(sso_secret_, other->sso_secret_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GenerateSSOTokenResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GenerateSSOTokenResponse_descriptor_;
+  metadata.reflection = GenerateSSOTokenResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int LogonUpdateRequest::kErrorCodeFieldNumber;
+#endif  // !_MSC_VER
+
+LogonUpdateRequest::LogonUpdateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.LogonUpdateRequest)
+}
+
+void LogonUpdateRequest::InitAsDefaultInstance() {
+}
+
+LogonUpdateRequest::LogonUpdateRequest(const LogonUpdateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.LogonUpdateRequest)
+}
+
+void LogonUpdateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  error_code_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+LogonUpdateRequest::~LogonUpdateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.LogonUpdateRequest)
+  SharedDtor();
+}
+
+void LogonUpdateRequest::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void LogonUpdateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* LogonUpdateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return LogonUpdateRequest_descriptor_;
+}
+
+const LogonUpdateRequest& LogonUpdateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+LogonUpdateRequest* LogonUpdateRequest::default_instance_ = NULL;
+
+LogonUpdateRequest* LogonUpdateRequest::New() const {
+  return new LogonUpdateRequest;
+}
+
+void LogonUpdateRequest::Clear() {
+  error_code_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool LogonUpdateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.LogonUpdateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required uint32 error_code = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &error_code_)));
+          set_has_error_code();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.LogonUpdateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.LogonUpdateRequest)
+  return false;
+#undef DO_
+}
+
+void LogonUpdateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.LogonUpdateRequest)
+  // required uint32 error_code = 1;
+  if (has_error_code()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->error_code(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.LogonUpdateRequest)
+}
+
+::google::protobuf::uint8* LogonUpdateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.LogonUpdateRequest)
+  // required uint32 error_code = 1;
+  if (has_error_code()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->error_code(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.LogonUpdateRequest)
+  return target;
+}
+
+int LogonUpdateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 error_code = 1;
+    if (has_error_code()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->error_code());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void LogonUpdateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const LogonUpdateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const LogonUpdateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void LogonUpdateRequest::MergeFrom(const LogonUpdateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_error_code()) {
+      set_error_code(from.error_code());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void LogonUpdateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void LogonUpdateRequest::CopyFrom(const LogonUpdateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool LogonUpdateRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  return true;
+}
+
+void LogonUpdateRequest::Swap(LogonUpdateRequest* other) {
+  if (other != this) {
+    std::swap(error_code_, other->error_code_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata LogonUpdateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = LogonUpdateRequest_descriptor_;
+  metadata.reflection = LogonUpdateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int LogonQueueUpdateRequest::kPositionFieldNumber;
+const int LogonQueueUpdateRequest::kEstimatedTimeFieldNumber;
+const int LogonQueueUpdateRequest::kEtaDeviationInSecFieldNumber;
+#endif  // !_MSC_VER
+
+LogonQueueUpdateRequest::LogonQueueUpdateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.LogonQueueUpdateRequest)
+}
+
+void LogonQueueUpdateRequest::InitAsDefaultInstance() {
+}
+
+LogonQueueUpdateRequest::LogonQueueUpdateRequest(const LogonQueueUpdateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.LogonQueueUpdateRequest)
+}
+
+void LogonQueueUpdateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  position_ = 0u;
+  estimated_time_ = GOOGLE_ULONGLONG(0);
+  eta_deviation_in_sec_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+LogonQueueUpdateRequest::~LogonQueueUpdateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.LogonQueueUpdateRequest)
+  SharedDtor();
+}
+
+void LogonQueueUpdateRequest::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void LogonQueueUpdateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* LogonQueueUpdateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return LogonQueueUpdateRequest_descriptor_;
+}
+
+const LogonQueueUpdateRequest& LogonQueueUpdateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+LogonQueueUpdateRequest* LogonQueueUpdateRequest::default_instance_ = NULL;
+
+LogonQueueUpdateRequest* LogonQueueUpdateRequest::New() const {
+  return new LogonQueueUpdateRequest;
+}
+
+void LogonQueueUpdateRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<LogonQueueUpdateRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(estimated_time_, position_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool LogonQueueUpdateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.LogonQueueUpdateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required uint32 position = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &position_)));
+          set_has_position();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_estimated_time;
+        break;
+      }
+
+      // required uint64 estimated_time = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_estimated_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &estimated_time_)));
+          set_has_estimated_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_eta_deviation_in_sec;
+        break;
+      }
+
+      // required uint64 eta_deviation_in_sec = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_eta_deviation_in_sec:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &eta_deviation_in_sec_)));
+          set_has_eta_deviation_in_sec();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.LogonQueueUpdateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.LogonQueueUpdateRequest)
+  return false;
+#undef DO_
+}
+
+void LogonQueueUpdateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.LogonQueueUpdateRequest)
+  // required uint32 position = 1;
+  if (has_position()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->position(), output);
+  }
+
+  // required uint64 estimated_time = 2;
+  if (has_estimated_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->estimated_time(), output);
+  }
+
+  // required uint64 eta_deviation_in_sec = 3;
+  if (has_eta_deviation_in_sec()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->eta_deviation_in_sec(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.LogonQueueUpdateRequest)
+}
+
+::google::protobuf::uint8* LogonQueueUpdateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.LogonQueueUpdateRequest)
+  // required uint32 position = 1;
+  if (has_position()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->position(), target);
+  }
+
+  // required uint64 estimated_time = 2;
+  if (has_estimated_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->estimated_time(), target);
+  }
+
+  // required uint64 eta_deviation_in_sec = 3;
+  if (has_eta_deviation_in_sec()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->eta_deviation_in_sec(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.LogonQueueUpdateRequest)
+  return target;
+}
+
+int LogonQueueUpdateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 position = 1;
+    if (has_position()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->position());
+    }
+
+    // required uint64 estimated_time = 2;
+    if (has_estimated_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->estimated_time());
+    }
+
+    // required uint64 eta_deviation_in_sec = 3;
+    if (has_eta_deviation_in_sec()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->eta_deviation_in_sec());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void LogonQueueUpdateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const LogonQueueUpdateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const LogonQueueUpdateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void LogonQueueUpdateRequest::MergeFrom(const LogonQueueUpdateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_position()) {
+      set_position(from.position());
+    }
+    if (from.has_estimated_time()) {
+      set_estimated_time(from.estimated_time());
+    }
+    if (from.has_eta_deviation_in_sec()) {
+      set_eta_deviation_in_sec(from.eta_deviation_in_sec());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void LogonQueueUpdateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void LogonQueueUpdateRequest::CopyFrom(const LogonQueueUpdateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool LogonQueueUpdateRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
+
+  return true;
+}
+
+void LogonQueueUpdateRequest::Swap(LogonQueueUpdateRequest* other) {
+  if (other != this) {
+    std::swap(position_, other->position_);
+    std::swap(estimated_time_, other->estimated_time_);
+    std::swap(eta_deviation_in_sec_, other->eta_deviation_in_sec_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata LogonQueueUpdateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = LogonQueueUpdateRequest_descriptor_;
+  metadata.reflection = LogonQueueUpdateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountSettingsNotification::kLicensesFieldNumber;
+const int AccountSettingsNotification::kIsUsingRidFieldNumber;
+const int AccountSettingsNotification::kIsPlayingFromIgrFieldNumber;
+const int AccountSettingsNotification::kCanReceiveVoiceFieldNumber;
+const int AccountSettingsNotification::kCanSendVoiceFieldNumber;
+#endif  // !_MSC_VER
+
+AccountSettingsNotification::AccountSettingsNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.AccountSettingsNotification)
+}
+
+void AccountSettingsNotification::InitAsDefaultInstance() {
+}
+
+AccountSettingsNotification::AccountSettingsNotification(const AccountSettingsNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.AccountSettingsNotification)
+}
+
+void AccountSettingsNotification::SharedCtor() {
+  _cached_size_ = 0;
+  is_using_rid_ = false;
+  is_playing_from_igr_ = false;
+  can_receive_voice_ = false;
+  can_send_voice_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountSettingsNotification::~AccountSettingsNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.AccountSettingsNotification)
+  SharedDtor();
+}
+
+void AccountSettingsNotification::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void AccountSettingsNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountSettingsNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountSettingsNotification_descriptor_;
+}
+
+const AccountSettingsNotification& AccountSettingsNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+AccountSettingsNotification* AccountSettingsNotification::default_instance_ = NULL;
+
+AccountSettingsNotification* AccountSettingsNotification::New() const {
+  return new AccountSettingsNotification;
+}
+
+void AccountSettingsNotification::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<AccountSettingsNotification*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(is_using_rid_, can_send_voice_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  licenses_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountSettingsNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.AccountSettingsNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_licenses:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_licenses()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_licenses;
+        if (input->ExpectTag(16)) goto parse_is_using_rid;
+        break;
+      }
+
+      // optional bool is_using_rid = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_is_using_rid:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_using_rid_)));
+          set_has_is_using_rid();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_is_playing_from_igr;
+        break;
+      }
+
+      // optional bool is_playing_from_igr = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_is_playing_from_igr:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_playing_from_igr_)));
+          set_has_is_playing_from_igr();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_can_receive_voice;
+        break;
+      }
+
+      // optional bool can_receive_voice = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_can_receive_voice:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_receive_voice_)));
+          set_has_can_receive_voice();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_can_send_voice;
+        break;
+      }
+
+      // optional bool can_send_voice = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_can_send_voice:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &can_send_voice_)));
+          set_has_can_send_voice();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.AccountSettingsNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.AccountSettingsNotification)
+  return false;
+#undef DO_
+}
+
+void AccountSettingsNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.AccountSettingsNotification)
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1;
+  for (int i = 0; i < this->licenses_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->licenses(i), output);
+  }
+
+  // optional bool is_using_rid = 2;
+  if (has_is_using_rid()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->is_using_rid(), output);
+  }
+
+  // optional bool is_playing_from_igr = 3;
+  if (has_is_playing_from_igr()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->is_playing_from_igr(), output);
+  }
+
+  // optional bool can_receive_voice = 4;
+  if (has_can_receive_voice()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->can_receive_voice(), output);
+  }
+
+  // optional bool can_send_voice = 5;
+  if (has_can_send_voice()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->can_send_voice(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.AccountSettingsNotification)
+}
+
+::google::protobuf::uint8* AccountSettingsNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.AccountSettingsNotification)
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1;
+  for (int i = 0; i < this->licenses_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->licenses(i), target);
+  }
+
+  // optional bool is_using_rid = 2;
+  if (has_is_using_rid()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->is_using_rid(), target);
+  }
+
+  // optional bool is_playing_from_igr = 3;
+  if (has_is_playing_from_igr()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->is_playing_from_igr(), target);
+  }
+
+  // optional bool can_receive_voice = 4;
+  if (has_can_receive_voice()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->can_receive_voice(), target);
+  }
+
+  // optional bool can_send_voice = 5;
+  if (has_can_send_voice()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->can_send_voice(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.AccountSettingsNotification)
+  return target;
+}
+
+int AccountSettingsNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional bool is_using_rid = 2;
+    if (has_is_using_rid()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool is_playing_from_igr = 3;
+    if (has_is_playing_from_igr()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool can_receive_voice = 4;
+    if (has_can_receive_voice()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool can_send_voice = 5;
+    if (has_can_send_voice()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1;
+  total_size += 1 * this->licenses_size();
+  for (int i = 0; i < this->licenses_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->licenses(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountSettingsNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountSettingsNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountSettingsNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountSettingsNotification::MergeFrom(const AccountSettingsNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  licenses_.MergeFrom(from.licenses_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_is_using_rid()) {
+      set_is_using_rid(from.is_using_rid());
+    }
+    if (from.has_is_playing_from_igr()) {
+      set_is_playing_from_igr(from.is_playing_from_igr());
+    }
+    if (from.has_can_receive_voice()) {
+      set_can_receive_voice(from.can_receive_voice());
+    }
+    if (from.has_can_send_voice()) {
+      set_can_send_voice(from.can_send_voice());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountSettingsNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountSettingsNotification::CopyFrom(const AccountSettingsNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountSettingsNotification::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->licenses())) return false;
+  return true;
+}
+
+void AccountSettingsNotification::Swap(AccountSettingsNotification* other) {
+  if (other != this) {
+    licenses_.Swap(&other->licenses_);
+    std::swap(is_using_rid_, other->is_using_rid_);
+    std::swap(is_playing_from_igr_, other->is_playing_from_igr_);
+    std::swap(can_receive_voice_, other->can_receive_voice_);
+    std::swap(can_send_voice_, other->can_send_voice_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountSettingsNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountSettingsNotification_descriptor_;
+  metadata.reflection = AccountSettingsNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ServerStateChangeRequest::kStateFieldNumber;
+const int ServerStateChangeRequest::kEventTimeFieldNumber;
+#endif  // !_MSC_VER
+
+ServerStateChangeRequest::ServerStateChangeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.ServerStateChangeRequest)
+}
+
+void ServerStateChangeRequest::InitAsDefaultInstance() {
+}
+
+ServerStateChangeRequest::ServerStateChangeRequest(const ServerStateChangeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.ServerStateChangeRequest)
+}
+
+void ServerStateChangeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  state_ = 0u;
+  event_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ServerStateChangeRequest::~ServerStateChangeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.ServerStateChangeRequest)
+  SharedDtor();
+}
+
+void ServerStateChangeRequest::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ServerStateChangeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ServerStateChangeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ServerStateChangeRequest_descriptor_;
+}
+
+const ServerStateChangeRequest& ServerStateChangeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ServerStateChangeRequest* ServerStateChangeRequest::default_instance_ = NULL;
+
+ServerStateChangeRequest* ServerStateChangeRequest::New() const {
+  return new ServerStateChangeRequest;
+}
+
+void ServerStateChangeRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ServerStateChangeRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(event_time_, state_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ServerStateChangeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.ServerStateChangeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required uint32 state = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &state_)));
+          set_has_state();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_event_time;
+        break;
+      }
+
+      // required uint64 event_time = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_event_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &event_time_)));
+          set_has_event_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.ServerStateChangeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.ServerStateChangeRequest)
+  return false;
+#undef DO_
+}
+
+void ServerStateChangeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.ServerStateChangeRequest)
+  // required uint32 state = 1;
+  if (has_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->state(), output);
+  }
+
+  // required uint64 event_time = 2;
+  if (has_event_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->event_time(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.ServerStateChangeRequest)
+}
+
+::google::protobuf::uint8* ServerStateChangeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.ServerStateChangeRequest)
+  // required uint32 state = 1;
+  if (has_state()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->state(), target);
+  }
+
+  // required uint64 event_time = 2;
+  if (has_event_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->event_time(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.ServerStateChangeRequest)
+  return target;
+}
+
+int ServerStateChangeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 state = 1;
+    if (has_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->state());
+    }
+
+    // required uint64 event_time = 2;
+    if (has_event_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->event_time());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ServerStateChangeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ServerStateChangeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ServerStateChangeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ServerStateChangeRequest::MergeFrom(const ServerStateChangeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_state()) {
+      set_state(from.state());
+    }
+    if (from.has_event_time()) {
+      set_event_time(from.event_time());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ServerStateChangeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ServerStateChangeRequest::CopyFrom(const ServerStateChangeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ServerStateChangeRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  return true;
+}
+
+void ServerStateChangeRequest::Swap(ServerStateChangeRequest* other) {
+  if (other != this) {
+    std::swap(state_, other->state_);
+    std::swap(event_time_, other->event_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ServerStateChangeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ServerStateChangeRequest_descriptor_;
+  metadata.reflection = ServerStateChangeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int VersionInfo::kNumberFieldNumber;
+const int VersionInfo::kPatchFieldNumber;
+const int VersionInfo::kIsOptionalFieldNumber;
+const int VersionInfo::kKickTimeFieldNumber;
+#endif  // !_MSC_VER
+
+VersionInfo::VersionInfo()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.VersionInfo)
+}
+
+void VersionInfo::InitAsDefaultInstance() {
+}
+
+VersionInfo::VersionInfo(const VersionInfo& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.VersionInfo)
+}
+
+void VersionInfo::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  number_ = 0u;
+  patch_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  is_optional_ = false;
+  kick_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+VersionInfo::~VersionInfo() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.VersionInfo)
+  SharedDtor();
+}
+
+void VersionInfo::SharedDtor() {
+  if (patch_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete patch_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void VersionInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* VersionInfo::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return VersionInfo_descriptor_;
+}
+
+const VersionInfo& VersionInfo::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+VersionInfo* VersionInfo::default_instance_ = NULL;
+
+VersionInfo* VersionInfo::New() const {
+  return new VersionInfo;
+}
+
+void VersionInfo::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<VersionInfo*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(number_, kick_time_);
+    if (has_patch()) {
+      if (patch_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        patch_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool VersionInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.VersionInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 number = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &number_)));
+          set_has_number();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_patch;
+        break;
+      }
+
+      // optional string patch = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_patch:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_patch()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->patch().data(), this->patch().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "patch");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_is_optional;
+        break;
+      }
+
+      // optional bool is_optional = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_is_optional:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_optional_)));
+          set_has_is_optional();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_kick_time;
+        break;
+      }
+
+      // optional uint64 kick_time = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_kick_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &kick_time_)));
+          set_has_kick_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.VersionInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.VersionInfo)
+  return false;
+#undef DO_
+}
+
+void VersionInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.VersionInfo)
+  // optional uint32 number = 1;
+  if (has_number()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->number(), output);
+  }
+
+  // optional string patch = 2;
+  if (has_patch()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->patch().data(), this->patch().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "patch");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->patch(), output);
+  }
+
+  // optional bool is_optional = 3;
+  if (has_is_optional()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->is_optional(), output);
+  }
+
+  // optional uint64 kick_time = 4;
+  if (has_kick_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->kick_time(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.VersionInfo)
+}
+
+::google::protobuf::uint8* VersionInfo::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.VersionInfo)
+  // optional uint32 number = 1;
+  if (has_number()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->number(), target);
+  }
+
+  // optional string patch = 2;
+  if (has_patch()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->patch().data(), this->patch().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "patch");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->patch(), target);
+  }
+
+  // optional bool is_optional = 3;
+  if (has_is_optional()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->is_optional(), target);
+  }
+
+  // optional uint64 kick_time = 4;
+  if (has_kick_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->kick_time(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.VersionInfo)
+  return target;
+}
+
+int VersionInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 number = 1;
+    if (has_number()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->number());
+    }
+
+    // optional string patch = 2;
+    if (has_patch()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->patch());
+    }
+
+    // optional bool is_optional = 3;
+    if (has_is_optional()) {
+      total_size += 1 + 1;
+    }
+
+    // optional uint64 kick_time = 4;
+    if (has_kick_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->kick_time());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void VersionInfo::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const VersionInfo* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const VersionInfo*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void VersionInfo::MergeFrom(const VersionInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_number()) {
+      set_number(from.number());
+    }
+    if (from.has_patch()) {
+      set_patch(from.patch());
+    }
+    if (from.has_is_optional()) {
+      set_is_optional(from.is_optional());
+    }
+    if (from.has_kick_time()) {
+      set_kick_time(from.kick_time());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void VersionInfo::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void VersionInfo::CopyFrom(const VersionInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool VersionInfo::IsInitialized() const {
+
+  return true;
+}
+
+void VersionInfo::Swap(VersionInfo* other) {
+  if (other != this) {
+    std::swap(number_, other->number_);
+    std::swap(patch_, other->patch_);
+    std::swap(is_optional_, other->is_optional_);
+    std::swap(kick_time_, other->kick_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata VersionInfo::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = VersionInfo_descriptor_;
+  metadata.reflection = VersionInfo_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int VersionInfoNotification::kVersionInfoFieldNumber;
+#endif  // !_MSC_VER
+
+VersionInfoNotification::VersionInfoNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.VersionInfoNotification)
+}
+
+void VersionInfoNotification::InitAsDefaultInstance() {
+  version_info_ = const_cast< ::bgs::protocol::authentication::v1::VersionInfo*>(&::bgs::protocol::authentication::v1::VersionInfo::default_instance());
+}
+
+VersionInfoNotification::VersionInfoNotification(const VersionInfoNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.VersionInfoNotification)
+}
+
+void VersionInfoNotification::SharedCtor() {
+  _cached_size_ = 0;
+  version_info_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+VersionInfoNotification::~VersionInfoNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.VersionInfoNotification)
+  SharedDtor();
+}
+
+void VersionInfoNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete version_info_;
+  }
+}
+
+void VersionInfoNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* VersionInfoNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return VersionInfoNotification_descriptor_;
+}
+
+const VersionInfoNotification& VersionInfoNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+VersionInfoNotification* VersionInfoNotification::default_instance_ = NULL;
+
+VersionInfoNotification* VersionInfoNotification::New() const {
+  return new VersionInfoNotification;
+}
+
+void VersionInfoNotification::Clear() {
+  if (has_version_info()) {
+    if (version_info_ != NULL) version_info_->::bgs::protocol::authentication::v1::VersionInfo::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool VersionInfoNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.VersionInfoNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.authentication.v1.VersionInfo version_info = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_version_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.VersionInfoNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.VersionInfoNotification)
+  return false;
+#undef DO_
+}
+
+void VersionInfoNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.VersionInfoNotification)
+  // optional .bgs.protocol.authentication.v1.VersionInfo version_info = 1;
+  if (has_version_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->version_info(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.VersionInfoNotification)
+}
+
+::google::protobuf::uint8* VersionInfoNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.VersionInfoNotification)
+  // optional .bgs.protocol.authentication.v1.VersionInfo version_info = 1;
+  if (has_version_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->version_info(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.VersionInfoNotification)
+  return target;
+}
+
+int VersionInfoNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.authentication.v1.VersionInfo version_info = 1;
+    if (has_version_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->version_info());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void VersionInfoNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const VersionInfoNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const VersionInfoNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void VersionInfoNotification::MergeFrom(const VersionInfoNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_version_info()) {
+      mutable_version_info()->::bgs::protocol::authentication::v1::VersionInfo::MergeFrom(from.version_info());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void VersionInfoNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void VersionInfoNotification::CopyFrom(const VersionInfoNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool VersionInfoNotification::IsInitialized() const {
+
+  return true;
+}
+
+void VersionInfoNotification::Swap(VersionInfoNotification* other) {
+  if (other != this) {
+    std::swap(version_info_, other->version_info_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata VersionInfoNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = VersionInfoNotification_descriptor_;
+  metadata.reflection = VersionInfoNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemModuleLoadRequest::kHandleFieldNumber;
+const int MemModuleLoadRequest::kKeyFieldNumber;
+const int MemModuleLoadRequest::kInputFieldNumber;
+#endif  // !_MSC_VER
+
+MemModuleLoadRequest::MemModuleLoadRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.MemModuleLoadRequest)
+}
+
+void MemModuleLoadRequest::InitAsDefaultInstance() {
+  handle_ = const_cast< ::bgs::protocol::ContentHandle*>(&::bgs::protocol::ContentHandle::default_instance());
+}
+
+MemModuleLoadRequest::MemModuleLoadRequest(const MemModuleLoadRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.MemModuleLoadRequest)
+}
+
+void MemModuleLoadRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  handle_ = NULL;
+  key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  input_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemModuleLoadRequest::~MemModuleLoadRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.MemModuleLoadRequest)
+  SharedDtor();
+}
+
+void MemModuleLoadRequest::SharedDtor() {
+  if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete key_;
+  }
+  if (input_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete input_;
+  }
+  if (this != default_instance_) {
+    delete handle_;
+  }
+}
+
+void MemModuleLoadRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemModuleLoadRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemModuleLoadRequest_descriptor_;
+}
+
+const MemModuleLoadRequest& MemModuleLoadRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+MemModuleLoadRequest* MemModuleLoadRequest::default_instance_ = NULL;
+
+MemModuleLoadRequest* MemModuleLoadRequest::New() const {
+  return new MemModuleLoadRequest;
+}
+
+void MemModuleLoadRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_handle()) {
+      if (handle_ != NULL) handle_->::bgs::protocol::ContentHandle::Clear();
+    }
+    if (has_key()) {
+      if (key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        key_->clear();
+      }
+    }
+    if (has_input()) {
+      if (input_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        input_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemModuleLoadRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.MemModuleLoadRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.ContentHandle handle = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_handle()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_key;
+        break;
+      }
+
+      // required bytes key = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_key:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_key()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_input;
+        break;
+      }
+
+      // required bytes input = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_input:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_input()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.MemModuleLoadRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.MemModuleLoadRequest)
+  return false;
+#undef DO_
+}
+
+void MemModuleLoadRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.MemModuleLoadRequest)
+  // required .bgs.protocol.ContentHandle handle = 1;
+  if (has_handle()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->handle(), output);
+  }
+
+  // required bytes key = 2;
+  if (has_key()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->key(), output);
+  }
+
+  // required bytes input = 3;
+  if (has_input()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      3, this->input(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.MemModuleLoadRequest)
+}
+
+::google::protobuf::uint8* MemModuleLoadRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.MemModuleLoadRequest)
+  // required .bgs.protocol.ContentHandle handle = 1;
+  if (has_handle()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->handle(), target);
+  }
+
+  // required bytes key = 2;
+  if (has_key()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        2, this->key(), target);
+  }
+
+  // required bytes input = 3;
+  if (has_input()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        3, this->input(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.MemModuleLoadRequest)
+  return target;
+}
+
+int MemModuleLoadRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.ContentHandle handle = 1;
+    if (has_handle()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->handle());
+    }
+
+    // required bytes key = 2;
+    if (has_key()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->key());
+    }
+
+    // required bytes input = 3;
+    if (has_input()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->input());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemModuleLoadRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemModuleLoadRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemModuleLoadRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemModuleLoadRequest::MergeFrom(const MemModuleLoadRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_handle()) {
+      mutable_handle()->::bgs::protocol::ContentHandle::MergeFrom(from.handle());
+    }
+    if (from.has_key()) {
+      set_key(from.key());
+    }
+    if (from.has_input()) {
+      set_input(from.input());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemModuleLoadRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemModuleLoadRequest::CopyFrom(const MemModuleLoadRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemModuleLoadRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
+
+  if (has_handle()) {
+    if (!this->handle().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void MemModuleLoadRequest::Swap(MemModuleLoadRequest* other) {
+  if (other != this) {
+    std::swap(handle_, other->handle_);
+    std::swap(key_, other->key_);
+    std::swap(input_, other->input_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemModuleLoadRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemModuleLoadRequest_descriptor_;
+  metadata.reflection = MemModuleLoadRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemModuleLoadResponse::kDataFieldNumber;
+#endif  // !_MSC_VER
+
+MemModuleLoadResponse::MemModuleLoadResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.MemModuleLoadResponse)
+}
+
+void MemModuleLoadResponse::InitAsDefaultInstance() {
+}
+
+MemModuleLoadResponse::MemModuleLoadResponse(const MemModuleLoadResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.MemModuleLoadResponse)
+}
+
+void MemModuleLoadResponse::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemModuleLoadResponse::~MemModuleLoadResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.MemModuleLoadResponse)
+  SharedDtor();
+}
+
+void MemModuleLoadResponse::SharedDtor() {
+  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete data_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void MemModuleLoadResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemModuleLoadResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemModuleLoadResponse_descriptor_;
+}
+
+const MemModuleLoadResponse& MemModuleLoadResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+MemModuleLoadResponse* MemModuleLoadResponse::default_instance_ = NULL;
+
+MemModuleLoadResponse* MemModuleLoadResponse::New() const {
+  return new MemModuleLoadResponse;
+}
+
+void MemModuleLoadResponse::Clear() {
+  if (has_data()) {
+    if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      data_->clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemModuleLoadResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.MemModuleLoadResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required bytes data = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_data()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.MemModuleLoadResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.MemModuleLoadResponse)
+  return false;
+#undef DO_
+}
+
+void MemModuleLoadResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.MemModuleLoadResponse)
+  // required bytes data = 1;
+  if (has_data()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->data(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.MemModuleLoadResponse)
+}
+
+::google::protobuf::uint8* MemModuleLoadResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.MemModuleLoadResponse)
+  // required bytes data = 1;
+  if (has_data()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        1, this->data(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.MemModuleLoadResponse)
+  return target;
+}
+
+int MemModuleLoadResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required bytes data = 1;
+    if (has_data()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->data());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemModuleLoadResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemModuleLoadResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemModuleLoadResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemModuleLoadResponse::MergeFrom(const MemModuleLoadResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_data()) {
+      set_data(from.data());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemModuleLoadResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemModuleLoadResponse::CopyFrom(const MemModuleLoadResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemModuleLoadResponse::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  return true;
+}
+
+void MemModuleLoadResponse::Swap(MemModuleLoadResponse* other) {
+  if (other != this) {
+    std::swap(data_, other->data_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemModuleLoadResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemModuleLoadResponse_descriptor_;
+  metadata.reflection = MemModuleLoadResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SelectGameAccountRequest::kGameAccountIdFieldNumber;
+#endif  // !_MSC_VER
+
+SelectGameAccountRequest::SelectGameAccountRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.SelectGameAccountRequest)
+}
+
+void SelectGameAccountRequest::InitAsDefaultInstance() {
+  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+SelectGameAccountRequest::SelectGameAccountRequest(const SelectGameAccountRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.SelectGameAccountRequest)
+}
+
+void SelectGameAccountRequest::SharedCtor() {
+  _cached_size_ = 0;
+  game_account_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SelectGameAccountRequest::~SelectGameAccountRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.SelectGameAccountRequest)
+  SharedDtor();
+}
+
+void SelectGameAccountRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete game_account_id_;
+  }
+}
+
+void SelectGameAccountRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SelectGameAccountRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SelectGameAccountRequest_descriptor_;
+}
+
+const SelectGameAccountRequest& SelectGameAccountRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SelectGameAccountRequest* SelectGameAccountRequest::default_instance_ = NULL;
+
+SelectGameAccountRequest* SelectGameAccountRequest::New() const {
+  return new SelectGameAccountRequest;
+}
+
+void SelectGameAccountRequest::Clear() {
+  if (has_game_account_id()) {
+    if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SelectGameAccountRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.SelectGameAccountRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.EntityId game_account_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.SelectGameAccountRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.SelectGameAccountRequest)
+  return false;
+#undef DO_
+}
+
+void SelectGameAccountRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.SelectGameAccountRequest)
+  // required .bgs.protocol.EntityId game_account_id = 1;
+  if (has_game_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->game_account_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.SelectGameAccountRequest)
+}
+
+::google::protobuf::uint8* SelectGameAccountRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.SelectGameAccountRequest)
+  // required .bgs.protocol.EntityId game_account_id = 1;
+  if (has_game_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->game_account_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.SelectGameAccountRequest)
+  return target;
+}
+
+int SelectGameAccountRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.EntityId game_account_id = 1;
+    if (has_game_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SelectGameAccountRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SelectGameAccountRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SelectGameAccountRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SelectGameAccountRequest::MergeFrom(const SelectGameAccountRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_game_account_id()) {
+      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SelectGameAccountRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SelectGameAccountRequest::CopyFrom(const SelectGameAccountRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SelectGameAccountRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_game_account_id()) {
+    if (!this->game_account_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SelectGameAccountRequest::Swap(SelectGameAccountRequest* other) {
+  if (other != this) {
+    std::swap(game_account_id_, other->game_account_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SelectGameAccountRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SelectGameAccountRequest_descriptor_;
+  metadata.reflection = SelectGameAccountRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameAccountSelectedRequest::kResultFieldNumber;
+const int GameAccountSelectedRequest::kGameAccountIdFieldNumber;
+#endif  // !_MSC_VER
+
+GameAccountSelectedRequest::GameAccountSelectedRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.GameAccountSelectedRequest)
+}
+
+void GameAccountSelectedRequest::InitAsDefaultInstance() {
+  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+GameAccountSelectedRequest::GameAccountSelectedRequest(const GameAccountSelectedRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.GameAccountSelectedRequest)
+}
+
+void GameAccountSelectedRequest::SharedCtor() {
+  _cached_size_ = 0;
+  result_ = 0u;
+  game_account_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameAccountSelectedRequest::~GameAccountSelectedRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.GameAccountSelectedRequest)
+  SharedDtor();
+}
+
+void GameAccountSelectedRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete game_account_id_;
+  }
+}
+
+void GameAccountSelectedRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameAccountSelectedRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameAccountSelectedRequest_descriptor_;
+}
+
+const GameAccountSelectedRequest& GameAccountSelectedRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GameAccountSelectedRequest* GameAccountSelectedRequest::default_instance_ = NULL;
+
+GameAccountSelectedRequest* GameAccountSelectedRequest::New() const {
+  return new GameAccountSelectedRequest;
+}
+
+void GameAccountSelectedRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    result_ = 0u;
+    if (has_game_account_id()) {
+      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameAccountSelectedRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.GameAccountSelectedRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required uint32 result = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &result_)));
+          set_has_result();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_game_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId game_account_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_game_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.GameAccountSelectedRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.GameAccountSelectedRequest)
+  return false;
+#undef DO_
+}
+
+void GameAccountSelectedRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.GameAccountSelectedRequest)
+  // required uint32 result = 1;
+  if (has_result()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->result(), output);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->game_account_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.GameAccountSelectedRequest)
+}
+
+::google::protobuf::uint8* GameAccountSelectedRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.GameAccountSelectedRequest)
+  // required uint32 result = 1;
+  if (has_result()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->result(), target);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->game_account_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.GameAccountSelectedRequest)
+  return target;
+}
+
+int GameAccountSelectedRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 result = 1;
+    if (has_result()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->result());
+    }
+
+    // optional .bgs.protocol.EntityId game_account_id = 2;
+    if (has_game_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameAccountSelectedRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameAccountSelectedRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountSelectedRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameAccountSelectedRequest::MergeFrom(const GameAccountSelectedRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_result()) {
+      set_result(from.result());
+    }
+    if (from.has_game_account_id()) {
+      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameAccountSelectedRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameAccountSelectedRequest::CopyFrom(const GameAccountSelectedRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameAccountSelectedRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_game_account_id()) {
+    if (!this->game_account_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GameAccountSelectedRequest::Swap(GameAccountSelectedRequest* other) {
+  if (other != this) {
+    std::swap(result_, other->result_);
+    std::swap(game_account_id_, other->game_account_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameAccountSelectedRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameAccountSelectedRequest_descriptor_;
+  metadata.reflection = GameAccountSelectedRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GenerateWebCredentialsRequest::kProgramFieldNumber;
+#endif  // !_MSC_VER
+
+GenerateWebCredentialsRequest::GenerateWebCredentialsRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest)
+}
+
+void GenerateWebCredentialsRequest::InitAsDefaultInstance() {
+}
+
+GenerateWebCredentialsRequest::GenerateWebCredentialsRequest(const GenerateWebCredentialsRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest)
+}
+
+void GenerateWebCredentialsRequest::SharedCtor() {
+  _cached_size_ = 0;
+  program_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GenerateWebCredentialsRequest::~GenerateWebCredentialsRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest)
+  SharedDtor();
+}
+
+void GenerateWebCredentialsRequest::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GenerateWebCredentialsRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GenerateWebCredentialsRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GenerateWebCredentialsRequest_descriptor_;
+}
+
+const GenerateWebCredentialsRequest& GenerateWebCredentialsRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GenerateWebCredentialsRequest* GenerateWebCredentialsRequest::default_instance_ = NULL;
+
+GenerateWebCredentialsRequest* GenerateWebCredentialsRequest::New() const {
+  return new GenerateWebCredentialsRequest;
+}
+
+void GenerateWebCredentialsRequest::Clear() {
+  program_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GenerateWebCredentialsRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional fixed32 program = 1;
+      case 1: {
+        if (tag == 13) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest)
+  return false;
+#undef DO_
+}
+
+void GenerateWebCredentialsRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest)
+  // optional fixed32 program = 1;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->program(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest)
+}
+
+::google::protobuf::uint8* GenerateWebCredentialsRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest)
+  // optional fixed32 program = 1;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->program(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.GenerateWebCredentialsRequest)
+  return target;
+}
+
+int GenerateWebCredentialsRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional fixed32 program = 1;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GenerateWebCredentialsRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GenerateWebCredentialsRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GenerateWebCredentialsRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GenerateWebCredentialsRequest::MergeFrom(const GenerateWebCredentialsRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GenerateWebCredentialsRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GenerateWebCredentialsRequest::CopyFrom(const GenerateWebCredentialsRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GenerateWebCredentialsRequest::IsInitialized() const {
+
+  return true;
+}
+
+void GenerateWebCredentialsRequest::Swap(GenerateWebCredentialsRequest* other) {
+  if (other != this) {
+    std::swap(program_, other->program_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GenerateWebCredentialsRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GenerateWebCredentialsRequest_descriptor_;
+  metadata.reflection = GenerateWebCredentialsRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GenerateWebCredentialsResponse::kWebCredentialsFieldNumber;
+#endif  // !_MSC_VER
+
+GenerateWebCredentialsResponse::GenerateWebCredentialsResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse)
+}
+
+void GenerateWebCredentialsResponse::InitAsDefaultInstance() {
+}
+
+GenerateWebCredentialsResponse::GenerateWebCredentialsResponse(const GenerateWebCredentialsResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse)
+}
+
+void GenerateWebCredentialsResponse::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GenerateWebCredentialsResponse::~GenerateWebCredentialsResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse)
+  SharedDtor();
+}
+
+void GenerateWebCredentialsResponse::SharedDtor() {
+  if (web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete web_credentials_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void GenerateWebCredentialsResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GenerateWebCredentialsResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GenerateWebCredentialsResponse_descriptor_;
+}
+
+const GenerateWebCredentialsResponse& GenerateWebCredentialsResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GenerateWebCredentialsResponse* GenerateWebCredentialsResponse::default_instance_ = NULL;
+
+GenerateWebCredentialsResponse* GenerateWebCredentialsResponse::New() const {
+  return new GenerateWebCredentialsResponse;
+}
+
+void GenerateWebCredentialsResponse::Clear() {
+  if (has_web_credentials()) {
+    if (web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      web_credentials_->clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GenerateWebCredentialsResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes web_credentials = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_web_credentials()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse)
+  return false;
+#undef DO_
+}
+
+void GenerateWebCredentialsResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse)
+  // optional bytes web_credentials = 1;
+  if (has_web_credentials()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->web_credentials(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse)
+}
+
+::google::protobuf::uint8* GenerateWebCredentialsResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse)
+  // optional bytes web_credentials = 1;
+  if (has_web_credentials()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        1, this->web_credentials(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.GenerateWebCredentialsResponse)
+  return target;
+}
+
+int GenerateWebCredentialsResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes web_credentials = 1;
+    if (has_web_credentials()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->web_credentials());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GenerateWebCredentialsResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GenerateWebCredentialsResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GenerateWebCredentialsResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GenerateWebCredentialsResponse::MergeFrom(const GenerateWebCredentialsResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_web_credentials()) {
+      set_web_credentials(from.web_credentials());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GenerateWebCredentialsResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GenerateWebCredentialsResponse::CopyFrom(const GenerateWebCredentialsResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GenerateWebCredentialsResponse::IsInitialized() const {
+
+  return true;
+}
+
+void GenerateWebCredentialsResponse::Swap(GenerateWebCredentialsResponse* other) {
+  if (other != this) {
+    std::swap(web_credentials_, other->web_credentials_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GenerateWebCredentialsResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GenerateWebCredentialsResponse_descriptor_;
+  metadata.reflection = GenerateWebCredentialsResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int VerifyWebCredentialsRequest::kWebCredentialsFieldNumber;
+#endif  // !_MSC_VER
+
+VerifyWebCredentialsRequest::VerifyWebCredentialsRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest)
+}
+
+void VerifyWebCredentialsRequest::InitAsDefaultInstance() {
+}
+
+VerifyWebCredentialsRequest::VerifyWebCredentialsRequest(const VerifyWebCredentialsRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest)
+}
+
+void VerifyWebCredentialsRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  web_credentials_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+VerifyWebCredentialsRequest::~VerifyWebCredentialsRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest)
+  SharedDtor();
+}
+
+void VerifyWebCredentialsRequest::SharedDtor() {
+  if (web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete web_credentials_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void VerifyWebCredentialsRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* VerifyWebCredentialsRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return VerifyWebCredentialsRequest_descriptor_;
+}
+
+const VerifyWebCredentialsRequest& VerifyWebCredentialsRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_authentication_5fservice_2eproto();
+  return *default_instance_;
+}
+
+VerifyWebCredentialsRequest* VerifyWebCredentialsRequest::default_instance_ = NULL;
+
+VerifyWebCredentialsRequest* VerifyWebCredentialsRequest::New() const {
+  return new VerifyWebCredentialsRequest;
+}
+
+void VerifyWebCredentialsRequest::Clear() {
+  if (has_web_credentials()) {
+    if (web_credentials_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      web_credentials_->clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool VerifyWebCredentialsRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes web_credentials = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_web_credentials()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest)
+  return false;
+#undef DO_
+}
+
+void VerifyWebCredentialsRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest)
+  // optional bytes web_credentials = 1;
+  if (has_web_credentials()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->web_credentials(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest)
+}
+
+::google::protobuf::uint8* VerifyWebCredentialsRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest)
+  // optional bytes web_credentials = 1;
+  if (has_web_credentials()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        1, this->web_credentials(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.authentication.v1.VerifyWebCredentialsRequest)
+  return target;
+}
+
+int VerifyWebCredentialsRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes web_credentials = 1;
+    if (has_web_credentials()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->web_credentials());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void VerifyWebCredentialsRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const VerifyWebCredentialsRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const VerifyWebCredentialsRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void VerifyWebCredentialsRequest::MergeFrom(const VerifyWebCredentialsRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_web_credentials()) {
+      set_web_credentials(from.web_credentials());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void VerifyWebCredentialsRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void VerifyWebCredentialsRequest::CopyFrom(const VerifyWebCredentialsRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool VerifyWebCredentialsRequest::IsInitialized() const {
+
+  return true;
+}
+
+void VerifyWebCredentialsRequest::Swap(VerifyWebCredentialsRequest* other) {
+  if (other != this) {
+    std::swap(web_credentials_, other->web_credentials_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata VerifyWebCredentialsRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = VerifyWebCredentialsRequest_descriptor_;
+  metadata.reflection = VerifyWebCredentialsRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* AuthenticationListener::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AuthenticationListener_descriptor_;
+}
+
+void AuthenticationListener::OnModuleLoad(::bgs::protocol::authentication::v1::ModuleLoadRequest const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnModuleLoad(bgs.protocol.authentication.v1.ModuleLoadRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request);
+}
+
+void AuthenticationListener::OnModuleMessage(::bgs::protocol::authentication::v1::ModuleMessageRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnModuleMessage(bgs.protocol.authentication.v1.ModuleMessageRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 2, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AuthenticationListener::OnServerStateChange(::bgs::protocol::authentication::v1::ServerStateChangeRequest const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnServerStateChange(bgs.protocol.authentication.v1.ServerStateChangeRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 4, request);
+}
+
+void AuthenticationListener::OnLogonComplete(::bgs::protocol::authentication::v1::LogonResult const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnLogonComplete(bgs.protocol.authentication.v1.LogonResult{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 5, request);
+}
+
+void AuthenticationListener::OnMemModuleLoad(::bgs::protocol::authentication::v1::MemModuleLoadRequest const* request, std::function<void(::bgs::protocol::authentication::v1::MemModuleLoadResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnMemModuleLoad(bgs.protocol.authentication.v1.MemModuleLoadRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 6, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::authentication::v1::MemModuleLoadResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AuthenticationListener::OnLogonUpdate(::bgs::protocol::authentication::v1::LogonUpdateRequest const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnLogonUpdate(bgs.protocol.authentication.v1.LogonUpdateRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 10, request);
+}
+
+void AuthenticationListener::OnVersionInfoUpdated(::bgs::protocol::authentication::v1::VersionInfoNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnVersionInfoUpdated(bgs.protocol.authentication.v1.VersionInfoNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 11, request);
+}
+
+void AuthenticationListener::OnLogonQueueUpdate(::bgs::protocol::authentication::v1::LogonQueueUpdateRequest const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnLogonQueueUpdate(bgs.protocol.authentication.v1.LogonQueueUpdateRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 12, request);
+}
+
+void AuthenticationListener::OnLogonQueueEnd(::bgs::protocol::NoData const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnLogonQueueEnd(bgs.protocol.NoData{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 13, request);
+}
+
+void AuthenticationListener::OnGameAccountSelected(::bgs::protocol::authentication::v1::GameAccountSelectedRequest const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationListener.OnGameAccountSelected(bgs.protocol.authentication.v1.GameAccountSelectedRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 14, request);
+}
+
+void AuthenticationListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::authentication::v1::ModuleLoadRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnModuleLoad server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnModuleLoad(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnModuleLoad(bgs.protocol.authentication.v1.ModuleLoadRequest{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    case 2: {
+      ::bgs::protocol::authentication::v1::ModuleMessageRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnModuleMessage server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleOnModuleMessage(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnModuleMessage(bgs.protocol.authentication.v1.ModuleMessageRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 2, token, &response);
+      else
+        SendResponse(service_hash_, 2, token, status);
+      break;
+    }
+    case 4: {
+      ::bgs::protocol::authentication::v1::ServerStateChangeRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnServerStateChange server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnServerStateChange(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnServerStateChange(bgs.protocol.authentication.v1.ServerStateChangeRequest{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 4, token, status);
+      break;
+    }
+    case 5: {
+      ::bgs::protocol::authentication::v1::LogonResult request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnLogonComplete server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnLogonComplete(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnLogonComplete(bgs.protocol.authentication.v1.LogonResult{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 5, token, status);
+      break;
+    }
+    case 6: {
+      ::bgs::protocol::authentication::v1::MemModuleLoadRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnMemModuleLoad server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::authentication::v1::MemModuleLoadResponse response;
+      uint32 status = HandleOnMemModuleLoad(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnMemModuleLoad(bgs.protocol.authentication.v1.MemModuleLoadRequest{ %s }) returned bgs.protocol.authentication.v1.MemModuleLoadResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 6, token, &response);
+      else
+        SendResponse(service_hash_, 6, token, status);
+      break;
+    }
+    case 10: {
+      ::bgs::protocol::authentication::v1::LogonUpdateRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnLogonUpdate server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 10, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnLogonUpdate(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnLogonUpdate(bgs.protocol.authentication.v1.LogonUpdateRequest{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 10, token, status);
+      break;
+    }
+    case 11: {
+      ::bgs::protocol::authentication::v1::VersionInfoNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnVersionInfoUpdated server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 11, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnVersionInfoUpdated(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnVersionInfoUpdated(bgs.protocol.authentication.v1.VersionInfoNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 11, token, status);
+      break;
+    }
+    case 12: {
+      ::bgs::protocol::authentication::v1::LogonQueueUpdateRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnLogonQueueUpdate server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 12, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnLogonQueueUpdate(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnLogonQueueUpdate(bgs.protocol.authentication.v1.LogonQueueUpdateRequest{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 12, token, status);
+      break;
+    }
+    case 13: {
+      ::bgs::protocol::NoData request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnLogonQueueEnd server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 13, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnLogonQueueEnd(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnLogonQueueEnd(bgs.protocol.NoData{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 13, token, status);
+      break;
+    }
+    case 14: {
+      ::bgs::protocol::authentication::v1::GameAccountSelectedRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationListener.OnGameAccountSelected server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 14, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnGameAccountSelected(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationListener.OnGameAccountSelected(bgs.protocol.authentication.v1.GameAccountSelectedRequest{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 14, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 AuthenticationListener::HandleOnModuleLoad(::bgs::protocol::authentication::v1::ModuleLoadRequest const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnModuleLoad({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AuthenticationListener::HandleOnModuleMessage(::bgs::protocol::authentication::v1::ModuleMessageRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnModuleMessage({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AuthenticationListener::HandleOnServerStateChange(::bgs::protocol::authentication::v1::ServerStateChangeRequest const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnServerStateChange({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AuthenticationListener::HandleOnLogonComplete(::bgs::protocol::authentication::v1::LogonResult const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnLogonComplete({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AuthenticationListener::HandleOnMemModuleLoad(::bgs::protocol::authentication::v1::MemModuleLoadRequest const* request, ::bgs::protocol::authentication::v1::MemModuleLoadResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnMemModuleLoad({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AuthenticationListener::HandleOnLogonUpdate(::bgs::protocol::authentication::v1::LogonUpdateRequest const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnLogonUpdate({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AuthenticationListener::HandleOnVersionInfoUpdated(::bgs::protocol::authentication::v1::VersionInfoNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnVersionInfoUpdated({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AuthenticationListener::HandleOnLogonQueueUpdate(::bgs::protocol::authentication::v1::LogonQueueUpdateRequest const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnLogonQueueUpdate({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AuthenticationListener::HandleOnLogonQueueEnd(::bgs::protocol::NoData const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnLogonQueueEnd({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AuthenticationListener::HandleOnGameAccountSelected(::bgs::protocol::authentication::v1::GameAccountSelectedRequest const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationListener.OnGameAccountSelected({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* AuthenticationService::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AuthenticationService_descriptor_;
+}
+
+void AuthenticationService::Logon(::bgs::protocol::authentication::v1::LogonRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationService.Logon(bgs.protocol.authentication.v1.LogonRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AuthenticationService::ModuleNotify(::bgs::protocol::authentication::v1::ModuleNotification const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationService.ModuleNotify(bgs.protocol.authentication.v1.ModuleNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 2, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AuthenticationService::ModuleMessage(::bgs::protocol::authentication::v1::ModuleMessageRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationService.ModuleMessage(bgs.protocol.authentication.v1.ModuleMessageRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 3, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AuthenticationService::SelectGameAccount_DEPRECATED(::bgs::protocol::EntityId const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationService.SelectGameAccount_DEPRECATED(bgs.protocol.EntityId{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 4, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AuthenticationService::GenerateSSOToken(::bgs::protocol::authentication::v1::GenerateSSOTokenRequest const* request, std::function<void(::bgs::protocol::authentication::v1::GenerateSSOTokenResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationService.GenerateSSOToken(bgs.protocol.authentication.v1.GenerateSSOTokenRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 5, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::authentication::v1::GenerateSSOTokenResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AuthenticationService::SelectGameAccount(::bgs::protocol::authentication::v1::SelectGameAccountRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationService.SelectGameAccount(bgs.protocol.authentication.v1.SelectGameAccountRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 6, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AuthenticationService::VerifyWebCredentials(::bgs::protocol::authentication::v1::VerifyWebCredentialsRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationService.VerifyWebCredentials(bgs.protocol.authentication.v1.VerifyWebCredentialsRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 7, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AuthenticationService::GenerateWebCredentials(::bgs::protocol::authentication::v1::GenerateWebCredentialsRequest const* request, std::function<void(::bgs::protocol::authentication::v1::GenerateWebCredentialsResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method AuthenticationService.GenerateWebCredentials(bgs.protocol.authentication.v1.GenerateWebCredentialsRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 8, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::authentication::v1::GenerateWebCredentialsResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void AuthenticationService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::authentication::v1::LogonRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationService.Logon server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleLogon(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationService.Logon(bgs.protocol.authentication.v1.LogonRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 1, token, &response);
+      else
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    case 2: {
+      ::bgs::protocol::authentication::v1::ModuleNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationService.ModuleNotify server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleModuleNotify(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationService.ModuleNotify(bgs.protocol.authentication.v1.ModuleNotification{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 2, token, &response);
+      else
+        SendResponse(service_hash_, 2, token, status);
+      break;
+    }
+    case 3: {
+      ::bgs::protocol::authentication::v1::ModuleMessageRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationService.ModuleMessage server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleModuleMessage(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationService.ModuleMessage(bgs.protocol.authentication.v1.ModuleMessageRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 3, token, &response);
+      else
+        SendResponse(service_hash_, 3, token, status);
+      break;
+    }
+    case 4: {
+      ::bgs::protocol::EntityId request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationService.SelectGameAccount_DEPRECATED server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleSelectGameAccount_DEPRECATED(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationService.SelectGameAccount_DEPRECATED(bgs.protocol.EntityId{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 4, token, &response);
+      else
+        SendResponse(service_hash_, 4, token, status);
+      break;
+    }
+    case 5: {
+      ::bgs::protocol::authentication::v1::GenerateSSOTokenRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationService.GenerateSSOToken server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::authentication::v1::GenerateSSOTokenResponse response;
+      uint32 status = HandleGenerateSSOToken(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationService.GenerateSSOToken(bgs.protocol.authentication.v1.GenerateSSOTokenRequest{ %s }) returned bgs.protocol.authentication.v1.GenerateSSOTokenResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 5, token, &response);
+      else
+        SendResponse(service_hash_, 5, token, status);
+      break;
+    }
+    case 6: {
+      ::bgs::protocol::authentication::v1::SelectGameAccountRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationService.SelectGameAccount server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleSelectGameAccount(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationService.SelectGameAccount(bgs.protocol.authentication.v1.SelectGameAccountRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 6, token, &response);
+      else
+        SendResponse(service_hash_, 6, token, status);
+      break;
+    }
+    case 7: {
+      ::bgs::protocol::authentication::v1::VerifyWebCredentialsRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationService.VerifyWebCredentials server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleVerifyWebCredentials(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationService.VerifyWebCredentials(bgs.protocol.authentication.v1.VerifyWebCredentialsRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 7, token, &response);
+      else
+        SendResponse(service_hash_, 7, token, status);
+      break;
+    }
+    case 8: {
+      ::bgs::protocol::authentication::v1::GenerateWebCredentialsRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for AuthenticationService.GenerateWebCredentials server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 8, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::authentication::v1::GenerateWebCredentialsResponse response;
+      uint32 status = HandleGenerateWebCredentials(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method AuthenticationService.GenerateWebCredentials(bgs.protocol.authentication.v1.GenerateWebCredentialsRequest{ %s }) returned bgs.protocol.authentication.v1.GenerateWebCredentialsResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 8, token, &response);
+      else
+        SendResponse(service_hash_, 8, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 AuthenticationService::HandleLogon(::bgs::protocol::authentication::v1::LogonRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationService.Logon({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AuthenticationService::HandleModuleNotify(::bgs::protocol::authentication::v1::ModuleNotification const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationService.ModuleNotify({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AuthenticationService::HandleModuleMessage(::bgs::protocol::authentication::v1::ModuleMessageRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationService.ModuleMessage({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AuthenticationService::HandleSelectGameAccount_DEPRECATED(::bgs::protocol::EntityId const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationService.SelectGameAccount_DEPRECATED({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AuthenticationService::HandleGenerateSSOToken(::bgs::protocol::authentication::v1::GenerateSSOTokenRequest const* request, ::bgs::protocol::authentication::v1::GenerateSSOTokenResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationService.GenerateSSOToken({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AuthenticationService::HandleSelectGameAccount(::bgs::protocol::authentication::v1::SelectGameAccountRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationService.SelectGameAccount({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AuthenticationService::HandleVerifyWebCredentials(::bgs::protocol::authentication::v1::VerifyWebCredentialsRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationService.VerifyWebCredentials({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 AuthenticationService::HandleGenerateWebCredentials(::bgs::protocol::authentication::v1::GenerateWebCredentialsRequest const* request, ::bgs::protocol::authentication::v1::GenerateWebCredentialsResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method AuthenticationService.GenerateWebCredentials({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace authentication
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/authentication_service.pb.h b/src/server/proto/Client/authentication_service.pb.h
new file mode 100644
index 00000000000..1b46a60ed60
--- /dev/null
+++ b/src/server/proto/Client/authentication_service.pb.h
@@ -0,0 +1,5043 @@
+// 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:
+
+  template<typename HashSelector>
+  explicit AuthenticationListener(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  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:
+
+  template<typename HashSelector>
+  explicit AuthenticationService(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  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:bgs.protocol.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
diff --git a/src/server/proto/Client/challenge_service.pb.cc b/src/server/proto/Client/challenge_service.pb.cc
new file mode 100644
index 00000000000..c42f5e4f967
--- /dev/null
+++ b/src/server/proto/Client/challenge_service.pb.cc
@@ -0,0 +1,4746 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: challenge_service.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "challenge_service.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+#include "BattlenetRpcErrorCodes.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace challenge {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* Challenge_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Challenge_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ChallengePickedRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ChallengePickedRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ChallengePickedResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ChallengePickedResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ChallengeAnsweredRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ChallengeAnsweredRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ChallengeAnsweredResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ChallengeAnsweredResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ChallengeCancelledRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ChallengeCancelledRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SendChallengeToUserRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SendChallengeToUserRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SendChallengeToUserResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SendChallengeToUserResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ChallengeUserRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ChallengeUserRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ChallengeResultRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ChallengeResultRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ChallengeExternalRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ChallengeExternalRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ChallengeExternalResult_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ChallengeExternalResult_reflection_ = NULL;
+const ::google::protobuf::ServiceDescriptor* ChallengeService_descriptor_ = NULL;
+const ::google::protobuf::ServiceDescriptor* ChallengeListener_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_challenge_5fservice_2eproto() {
+  protobuf_AddDesc_challenge_5fservice_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "challenge_service.proto");
+  GOOGLE_CHECK(file != NULL);
+  Challenge_descriptor_ = file->message_type(0);
+  static const int Challenge_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, answer_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, retries_),
+  };
+  Challenge_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Challenge_descriptor_,
+      Challenge::default_instance_,
+      Challenge_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Challenge, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Challenge));
+  ChallengePickedRequest_descriptor_ = file->message_type(1);
+  static const int ChallengePickedRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedRequest, challenge_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedRequest, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedRequest, new_challenge_protocol_),
+  };
+  ChallengePickedRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ChallengePickedRequest_descriptor_,
+      ChallengePickedRequest::default_instance_,
+      ChallengePickedRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ChallengePickedRequest));
+  ChallengePickedResponse_descriptor_ = file->message_type(2);
+  static const int ChallengePickedResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedResponse, data_),
+  };
+  ChallengePickedResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ChallengePickedResponse_descriptor_,
+      ChallengePickedResponse::default_instance_,
+      ChallengePickedResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengePickedResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ChallengePickedResponse));
+  ChallengeAnsweredRequest_descriptor_ = file->message_type(3);
+  static const int ChallengeAnsweredRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredRequest, answer_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredRequest, data_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredRequest, id_),
+  };
+  ChallengeAnsweredRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ChallengeAnsweredRequest_descriptor_,
+      ChallengeAnsweredRequest::default_instance_,
+      ChallengeAnsweredRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ChallengeAnsweredRequest));
+  ChallengeAnsweredResponse_descriptor_ = file->message_type(4);
+  static const int ChallengeAnsweredResponse_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredResponse, data_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredResponse, do_retry_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredResponse, record_not_found_),
+  };
+  ChallengeAnsweredResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ChallengeAnsweredResponse_descriptor_,
+      ChallengeAnsweredResponse::default_instance_,
+      ChallengeAnsweredResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeAnsweredResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ChallengeAnsweredResponse));
+  ChallengeCancelledRequest_descriptor_ = file->message_type(5);
+  static const int ChallengeCancelledRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeCancelledRequest, id_),
+  };
+  ChallengeCancelledRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ChallengeCancelledRequest_descriptor_,
+      ChallengeCancelledRequest::default_instance_,
+      ChallengeCancelledRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeCancelledRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeCancelledRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ChallengeCancelledRequest));
+  SendChallengeToUserRequest_descriptor_ = file->message_type(6);
+  static const int SendChallengeToUserRequest_offsets_[8] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, peer_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, game_account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, challenges_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, context_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, timeout_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, attributes_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, host_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, account_id_),
+  };
+  SendChallengeToUserRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SendChallengeToUserRequest_descriptor_,
+      SendChallengeToUserRequest::default_instance_,
+      SendChallengeToUserRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SendChallengeToUserRequest));
+  SendChallengeToUserResponse_descriptor_ = file->message_type(7);
+  static const int SendChallengeToUserResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserResponse, id_),
+  };
+  SendChallengeToUserResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SendChallengeToUserResponse_descriptor_,
+      SendChallengeToUserResponse::default_instance_,
+      SendChallengeToUserResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendChallengeToUserResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SendChallengeToUserResponse));
+  ChallengeUserRequest_descriptor_ = file->message_type(8);
+  static const int ChallengeUserRequest_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, challenges_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, context_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, deadline_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, attributes_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, game_account_id_),
+  };
+  ChallengeUserRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ChallengeUserRequest_descriptor_,
+      ChallengeUserRequest::default_instance_,
+      ChallengeUserRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeUserRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ChallengeUserRequest));
+  ChallengeResultRequest_descriptor_ = file->message_type(9);
+  static const int ChallengeResultRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, error_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, answer_),
+  };
+  ChallengeResultRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ChallengeResultRequest_descriptor_,
+      ChallengeResultRequest::default_instance_,
+      ChallengeResultRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeResultRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ChallengeResultRequest));
+  ChallengeExternalRequest_descriptor_ = file->message_type(10);
+  static const int ChallengeExternalRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalRequest, request_token_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalRequest, payload_type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalRequest, payload_),
+  };
+  ChallengeExternalRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ChallengeExternalRequest_descriptor_,
+      ChallengeExternalRequest::default_instance_,
+      ChallengeExternalRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ChallengeExternalRequest));
+  ChallengeExternalResult_descriptor_ = file->message_type(11);
+  static const int ChallengeExternalResult_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalResult, request_token_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalResult, passed_),
+  };
+  ChallengeExternalResult_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ChallengeExternalResult_descriptor_,
+      ChallengeExternalResult::default_instance_,
+      ChallengeExternalResult_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalResult, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChallengeExternalResult, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ChallengeExternalResult));
+  ChallengeService_descriptor_ = file->service(0);
+  ChallengeListener_descriptor_ = file->service(1);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_challenge_5fservice_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Challenge_descriptor_, &Challenge::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ChallengePickedRequest_descriptor_, &ChallengePickedRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ChallengePickedResponse_descriptor_, &ChallengePickedResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ChallengeAnsweredRequest_descriptor_, &ChallengeAnsweredRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ChallengeAnsweredResponse_descriptor_, &ChallengeAnsweredResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ChallengeCancelledRequest_descriptor_, &ChallengeCancelledRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SendChallengeToUserRequest_descriptor_, &SendChallengeToUserRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SendChallengeToUserResponse_descriptor_, &SendChallengeToUserResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ChallengeUserRequest_descriptor_, &ChallengeUserRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ChallengeResultRequest_descriptor_, &ChallengeResultRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ChallengeExternalRequest_descriptor_, &ChallengeExternalRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ChallengeExternalResult_descriptor_, &ChallengeExternalResult::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_challenge_5fservice_2eproto() {
+  delete Challenge::default_instance_;
+  delete Challenge_reflection_;
+  delete ChallengePickedRequest::default_instance_;
+  delete ChallengePickedRequest_reflection_;
+  delete ChallengePickedResponse::default_instance_;
+  delete ChallengePickedResponse_reflection_;
+  delete ChallengeAnsweredRequest::default_instance_;
+  delete ChallengeAnsweredRequest_reflection_;
+  delete ChallengeAnsweredResponse::default_instance_;
+  delete ChallengeAnsweredResponse_reflection_;
+  delete ChallengeCancelledRequest::default_instance_;
+  delete ChallengeCancelledRequest_reflection_;
+  delete SendChallengeToUserRequest::default_instance_;
+  delete SendChallengeToUserRequest_reflection_;
+  delete SendChallengeToUserResponse::default_instance_;
+  delete SendChallengeToUserResponse_reflection_;
+  delete ChallengeUserRequest::default_instance_;
+  delete ChallengeUserRequest_reflection_;
+  delete ChallengeResultRequest::default_instance_;
+  delete ChallengeResultRequest_reflection_;
+  delete ChallengeExternalRequest::default_instance_;
+  delete ChallengeExternalRequest_reflection_;
+  delete ChallengeExternalResult::default_instance_;
+  delete ChallengeExternalResult_reflection_;
+}
+
+void protobuf_AddDesc_challenge_5fservice_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\027challenge_service.proto\022\031bgs.protocol."
+    "challenge.v1\032\025attribute_types.proto\032\022ent"
+    "ity_types.proto\032\017rpc_types.proto\"N\n\tChal"
+    "lenge\022\014\n\004type\030\001 \002(\007\022\014\n\004info\030\002 \001(\t\022\024\n\006ans"
+    "wer\030\003 \001(\tB\004\200\265\030\001\022\017\n\007retries\030\004 \001(\r\"^\n\026Chal"
+    "lengePickedRequest\022\021\n\tchallenge\030\001 \002(\007\022\n\n"
+    "\002id\030\002 \001(\r\022%\n\026new_challenge_protocol\030\003 \001("
+    "\010:\005false\"-\n\027ChallengePickedResponse\022\022\n\004d"
+    "ata\030\001 \001(\014B\004\200\265\030\001\"P\n\030ChallengeAnsweredRequ"
+    "est\022\024\n\006answer\030\001 \002(\tB\004\200\265\030\001\022\022\n\004data\030\002 \001(\014B"
+    "\004\200\265\030\001\022\n\n\002id\030\003 \001(\r\"[\n\031ChallengeAnsweredRe"
+    "sponse\022\022\n\004data\030\001 \001(\014B\004\200\265\030\001\022\020\n\010do_retry\030\002"
+    " \001(\010\022\030\n\020record_not_found\030\003 \001(\010\"\'\n\031Challe"
+    "ngeCancelledRequest\022\n\n\002id\030\001 \001(\r\"\323\002\n\032Send"
+    "ChallengeToUserRequest\022(\n\007peer_id\030\001 \001(\0132"
+    "\027.bgs.protocol.ProcessId\022/\n\017game_account"
+    "_id\030\002 \001(\0132\026.bgs.protocol.EntityId\0228\n\ncha"
+    "llenges\030\003 \003(\0132$.bgs.protocol.challenge.v"
+    "1.Challenge\022\017\n\007context\030\004 \002(\007\022\017\n\007timeout\030"
+    "\005 \001(\004\022+\n\nattributes\030\006 \003(\0132\027.bgs.protocol"
+    ".Attribute\022%\n\004host\030\007 \001(\0132\027.bgs.protocol."
+    "ProcessId\022*\n\naccount_id\030\010 \001(\0132\026.bgs.prot"
+    "ocol.EntityId\")\n\033SendChallengeToUserResp"
+    "onse\022\n\n\002id\030\001 \001(\r\"\335\001\n\024ChallengeUserReques"
+    "t\0228\n\nchallenges\030\001 \003(\0132$.bgs.protocol.cha"
+    "llenge.v1.Challenge\022\017\n\007context\030\002 \002(\007\022\n\n\002"
+    "id\030\003 \001(\r\022\020\n\010deadline\030\004 \001(\004\022+\n\nattributes"
+    "\030\005 \003(\0132\027.bgs.protocol.Attribute\022/\n\017game_"
+    "account_id\030\006 \001(\0132\026.bgs.protocol.EntityId"
+    "\"Z\n\026ChallengeResultRequest\022\n\n\002id\030\001 \001(\r\022\014"
+    "\n\004type\030\002 \001(\007\022\020\n\010error_id\030\003 \001(\r\022\024\n\006answer"
+    "\030\004 \001(\014B\004\200\265\030\001\"X\n\030ChallengeExternalRequest"
+    "\022\025\n\rrequest_token\030\001 \001(\t\022\024\n\014payload_type\030"
+    "\002 \001(\t\022\017\n\007payload\030\003 \001(\014\"F\n\027ChallengeExter"
+    "nalResult\022\025\n\rrequest_token\030\001 \001(\t\022\024\n\006pass"
+    "ed\030\002 \001(\010:\004true2\273\004\n\020ChallengeService\022~\n\017C"
+    "hallengePicked\0221.bgs.protocol.challenge."
+    "v1.ChallengePickedRequest\0322.bgs.protocol"
+    ".challenge.v1.ChallengePickedResponse\"\004\200"
+    "\265\030\001\022\204\001\n\021ChallengeAnswered\0223.bgs.protocol"
+    ".challenge.v1.ChallengeAnsweredRequest\0324"
+    ".bgs.protocol.challenge.v1.ChallengeAnsw"
+    "eredResponse\"\004\200\265\030\002\022f\n\022ChallengeCancelled"
+    "\0224.bgs.protocol.challenge.v1.ChallengeCa"
+    "ncelledRequest\032\024.bgs.protocol.NoData\"\004\200\265"
+    "\030\003\022\212\001\n\023SendChallengeToUser\0225.bgs.protoco"
+    "l.challenge.v1.SendChallengeToUserReques"
+    "t\0326.bgs.protocol.challenge.v1.SendChalle"
+    "ngeToUserResponse\"\004\200\265\030\004\032+\312>(bnet.protoco"
+    "l.challenge.ChallengeService2\354\003\n\021Challen"
+    "geListener\022c\n\017OnChallengeUser\022/.bgs.prot"
+    "ocol.challenge.v1.ChallengeUserRequest\032\031"
+    ".bgs.protocol.NO_RESPONSE\"\004\200\265\030\001\022g\n\021OnCha"
+    "llengeResult\0221.bgs.protocol.challenge.v1"
+    ".ChallengeResultRequest\032\031.bgs.protocol.N"
+    "O_RESPONSE\"\004\200\265\030\002\022k\n\023OnExternalChallenge\022"
+    "3.bgs.protocol.challenge.v1.ChallengeExt"
+    "ernalRequest\032\031.bgs.protocol.NO_RESPONSE\""
+    "\004\200\265\030\003\022p\n\031OnExternalChallengeResult\0222.bgs"
+    ".protocol.challenge.v1.ChallengeExternal"
+    "Result\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\004\032"
+    "*\312>\'bnet.protocol.challenge.ChallengeNot"
+    "ifyB\005H\001\200\001\000", 2490);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "challenge_service.proto", &protobuf_RegisterTypes);
+  Challenge::default_instance_ = new Challenge();
+  ChallengePickedRequest::default_instance_ = new ChallengePickedRequest();
+  ChallengePickedResponse::default_instance_ = new ChallengePickedResponse();
+  ChallengeAnsweredRequest::default_instance_ = new ChallengeAnsweredRequest();
+  ChallengeAnsweredResponse::default_instance_ = new ChallengeAnsweredResponse();
+  ChallengeCancelledRequest::default_instance_ = new ChallengeCancelledRequest();
+  SendChallengeToUserRequest::default_instance_ = new SendChallengeToUserRequest();
+  SendChallengeToUserResponse::default_instance_ = new SendChallengeToUserResponse();
+  ChallengeUserRequest::default_instance_ = new ChallengeUserRequest();
+  ChallengeResultRequest::default_instance_ = new ChallengeResultRequest();
+  ChallengeExternalRequest::default_instance_ = new ChallengeExternalRequest();
+  ChallengeExternalResult::default_instance_ = new ChallengeExternalResult();
+  Challenge::default_instance_->InitAsDefaultInstance();
+  ChallengePickedRequest::default_instance_->InitAsDefaultInstance();
+  ChallengePickedResponse::default_instance_->InitAsDefaultInstance();
+  ChallengeAnsweredRequest::default_instance_->InitAsDefaultInstance();
+  ChallengeAnsweredResponse::default_instance_->InitAsDefaultInstance();
+  ChallengeCancelledRequest::default_instance_->InitAsDefaultInstance();
+  SendChallengeToUserRequest::default_instance_->InitAsDefaultInstance();
+  SendChallengeToUserResponse::default_instance_->InitAsDefaultInstance();
+  ChallengeUserRequest::default_instance_->InitAsDefaultInstance();
+  ChallengeResultRequest::default_instance_->InitAsDefaultInstance();
+  ChallengeExternalRequest::default_instance_->InitAsDefaultInstance();
+  ChallengeExternalResult::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_challenge_5fservice_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_challenge_5fservice_2eproto {
+  StaticDescriptorInitializer_challenge_5fservice_2eproto() {
+    protobuf_AddDesc_challenge_5fservice_2eproto();
+  }
+} static_descriptor_initializer_challenge_5fservice_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Challenge::kTypeFieldNumber;
+const int Challenge::kInfoFieldNumber;
+const int Challenge::kAnswerFieldNumber;
+const int Challenge::kRetriesFieldNumber;
+#endif  // !_MSC_VER
+
+Challenge::Challenge()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.Challenge)
+}
+
+void Challenge::InitAsDefaultInstance() {
+}
+
+Challenge::Challenge(const Challenge& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.Challenge)
+}
+
+void Challenge::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  type_ = 0u;
+  info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  retries_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Challenge::~Challenge() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.Challenge)
+  SharedDtor();
+}
+
+void Challenge::SharedDtor() {
+  if (info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete info_;
+  }
+  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete answer_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void Challenge::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Challenge::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Challenge_descriptor_;
+}
+
+const Challenge& Challenge::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
+  return *default_instance_;
+}
+
+Challenge* Challenge::default_instance_ = NULL;
+
+Challenge* Challenge::New() const {
+  return new Challenge;
+}
+
+void Challenge::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<Challenge*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(type_, retries_);
+    if (has_info()) {
+      if (info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        info_->clear();
+      }
+    }
+    if (has_answer()) {
+      if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        answer_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Challenge::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.Challenge)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required fixed32 type = 1;
+      case 1: {
+        if (tag == 13) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &type_)));
+          set_has_type();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_info;
+        break;
+      }
+
+      // optional string info = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_info()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->info().data(), this->info().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "info");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_answer;
+        break;
+      }
+
+      // optional string answer = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_answer:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_answer()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->answer().data(), this->answer().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "answer");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_retries;
+        break;
+      }
+
+      // optional uint32 retries = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_retries:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &retries_)));
+          set_has_retries();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.Challenge)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.Challenge)
+  return false;
+#undef DO_
+}
+
+void Challenge::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.Challenge)
+  // required fixed32 type = 1;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->type(), output);
+  }
+
+  // optional string info = 2;
+  if (has_info()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->info().data(), this->info().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "info");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->info(), output);
+  }
+
+  // optional string answer = 3;
+  if (has_answer()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->answer().data(), this->answer().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "answer");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->answer(), output);
+  }
+
+  // optional uint32 retries = 4;
+  if (has_retries()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->retries(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.Challenge)
+}
+
+::google::protobuf::uint8* Challenge::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.Challenge)
+  // required fixed32 type = 1;
+  if (has_type()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->type(), target);
+  }
+
+  // optional string info = 2;
+  if (has_info()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->info().data(), this->info().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "info");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->info(), target);
+  }
+
+  // optional string answer = 3;
+  if (has_answer()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->answer().data(), this->answer().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "answer");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->answer(), target);
+  }
+
+  // optional uint32 retries = 4;
+  if (has_retries()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->retries(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.Challenge)
+  return target;
+}
+
+int Challenge::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required fixed32 type = 1;
+    if (has_type()) {
+      total_size += 1 + 4;
+    }
+
+    // optional string info = 2;
+    if (has_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->info());
+    }
+
+    // optional string answer = 3;
+    if (has_answer()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->answer());
+    }
+
+    // optional uint32 retries = 4;
+    if (has_retries()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->retries());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Challenge::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Challenge* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Challenge*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Challenge::MergeFrom(const Challenge& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_info()) {
+      set_info(from.info());
+    }
+    if (from.has_answer()) {
+      set_answer(from.answer());
+    }
+    if (from.has_retries()) {
+      set_retries(from.retries());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Challenge::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Challenge::CopyFrom(const Challenge& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Challenge::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  return true;
+}
+
+void Challenge::Swap(Challenge* other) {
+  if (other != this) {
+    std::swap(type_, other->type_);
+    std::swap(info_, other->info_);
+    std::swap(answer_, other->answer_);
+    std::swap(retries_, other->retries_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Challenge::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Challenge_descriptor_;
+  metadata.reflection = Challenge_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ChallengePickedRequest::kChallengeFieldNumber;
+const int ChallengePickedRequest::kIdFieldNumber;
+const int ChallengePickedRequest::kNewChallengeProtocolFieldNumber;
+#endif  // !_MSC_VER
+
+ChallengePickedRequest::ChallengePickedRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengePickedRequest)
+}
+
+void ChallengePickedRequest::InitAsDefaultInstance() {
+}
+
+ChallengePickedRequest::ChallengePickedRequest(const ChallengePickedRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengePickedRequest)
+}
+
+void ChallengePickedRequest::SharedCtor() {
+  _cached_size_ = 0;
+  challenge_ = 0u;
+  id_ = 0u;
+  new_challenge_protocol_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ChallengePickedRequest::~ChallengePickedRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengePickedRequest)
+  SharedDtor();
+}
+
+void ChallengePickedRequest::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ChallengePickedRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ChallengePickedRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChallengePickedRequest_descriptor_;
+}
+
+const ChallengePickedRequest& ChallengePickedRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ChallengePickedRequest* ChallengePickedRequest::default_instance_ = NULL;
+
+ChallengePickedRequest* ChallengePickedRequest::New() const {
+  return new ChallengePickedRequest;
+}
+
+void ChallengePickedRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ChallengePickedRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(challenge_, new_challenge_protocol_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ChallengePickedRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengePickedRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required fixed32 challenge = 1;
+      case 1: {
+        if (tag == 13) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &challenge_)));
+          set_has_challenge();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_id;
+        break;
+      }
+
+      // optional uint32 id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_new_challenge_protocol;
+        break;
+      }
+
+      // optional bool new_challenge_protocol = 3 [default = false];
+      case 3: {
+        if (tag == 24) {
+         parse_new_challenge_protocol:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &new_challenge_protocol_)));
+          set_has_new_challenge_protocol();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.ChallengePickedRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengePickedRequest)
+  return false;
+#undef DO_
+}
+
+void ChallengePickedRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengePickedRequest)
+  // required fixed32 challenge = 1;
+  if (has_challenge()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->challenge(), output);
+  }
+
+  // optional uint32 id = 2;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->id(), output);
+  }
+
+  // optional bool new_challenge_protocol = 3 [default = false];
+  if (has_new_challenge_protocol()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->new_challenge_protocol(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengePickedRequest)
+}
+
+::google::protobuf::uint8* ChallengePickedRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengePickedRequest)
+  // required fixed32 challenge = 1;
+  if (has_challenge()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->challenge(), target);
+  }
+
+  // optional uint32 id = 2;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->id(), target);
+  }
+
+  // optional bool new_challenge_protocol = 3 [default = false];
+  if (has_new_challenge_protocol()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->new_challenge_protocol(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengePickedRequest)
+  return target;
+}
+
+int ChallengePickedRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required fixed32 challenge = 1;
+    if (has_challenge()) {
+      total_size += 1 + 4;
+    }
+
+    // optional uint32 id = 2;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->id());
+    }
+
+    // optional bool new_challenge_protocol = 3 [default = false];
+    if (has_new_challenge_protocol()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ChallengePickedRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ChallengePickedRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ChallengePickedRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ChallengePickedRequest::MergeFrom(const ChallengePickedRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_challenge()) {
+      set_challenge(from.challenge());
+    }
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_new_challenge_protocol()) {
+      set_new_challenge_protocol(from.new_challenge_protocol());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ChallengePickedRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ChallengePickedRequest::CopyFrom(const ChallengePickedRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChallengePickedRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  return true;
+}
+
+void ChallengePickedRequest::Swap(ChallengePickedRequest* other) {
+  if (other != this) {
+    std::swap(challenge_, other->challenge_);
+    std::swap(id_, other->id_);
+    std::swap(new_challenge_protocol_, other->new_challenge_protocol_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ChallengePickedRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ChallengePickedRequest_descriptor_;
+  metadata.reflection = ChallengePickedRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ChallengePickedResponse::kDataFieldNumber;
+#endif  // !_MSC_VER
+
+ChallengePickedResponse::ChallengePickedResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengePickedResponse)
+}
+
+void ChallengePickedResponse::InitAsDefaultInstance() {
+}
+
+ChallengePickedResponse::ChallengePickedResponse(const ChallengePickedResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengePickedResponse)
+}
+
+void ChallengePickedResponse::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ChallengePickedResponse::~ChallengePickedResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengePickedResponse)
+  SharedDtor();
+}
+
+void ChallengePickedResponse::SharedDtor() {
+  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete data_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ChallengePickedResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ChallengePickedResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChallengePickedResponse_descriptor_;
+}
+
+const ChallengePickedResponse& ChallengePickedResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ChallengePickedResponse* ChallengePickedResponse::default_instance_ = NULL;
+
+ChallengePickedResponse* ChallengePickedResponse::New() const {
+  return new ChallengePickedResponse;
+}
+
+void ChallengePickedResponse::Clear() {
+  if (has_data()) {
+    if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+      data_->clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ChallengePickedResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengePickedResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes data = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_data()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.ChallengePickedResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengePickedResponse)
+  return false;
+#undef DO_
+}
+
+void ChallengePickedResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengePickedResponse)
+  // optional bytes data = 1;
+  if (has_data()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->data(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengePickedResponse)
+}
+
+::google::protobuf::uint8* ChallengePickedResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengePickedResponse)
+  // optional bytes data = 1;
+  if (has_data()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        1, this->data(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengePickedResponse)
+  return target;
+}
+
+int ChallengePickedResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes data = 1;
+    if (has_data()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->data());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ChallengePickedResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ChallengePickedResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ChallengePickedResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ChallengePickedResponse::MergeFrom(const ChallengePickedResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_data()) {
+      set_data(from.data());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ChallengePickedResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ChallengePickedResponse::CopyFrom(const ChallengePickedResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChallengePickedResponse::IsInitialized() const {
+
+  return true;
+}
+
+void ChallengePickedResponse::Swap(ChallengePickedResponse* other) {
+  if (other != this) {
+    std::swap(data_, other->data_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ChallengePickedResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ChallengePickedResponse_descriptor_;
+  metadata.reflection = ChallengePickedResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ChallengeAnsweredRequest::kAnswerFieldNumber;
+const int ChallengeAnsweredRequest::kDataFieldNumber;
+const int ChallengeAnsweredRequest::kIdFieldNumber;
+#endif  // !_MSC_VER
+
+ChallengeAnsweredRequest::ChallengeAnsweredRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
+}
+
+void ChallengeAnsweredRequest::InitAsDefaultInstance() {
+}
+
+ChallengeAnsweredRequest::ChallengeAnsweredRequest(const ChallengeAnsweredRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
+}
+
+void ChallengeAnsweredRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  id_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ChallengeAnsweredRequest::~ChallengeAnsweredRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
+  SharedDtor();
+}
+
+void ChallengeAnsweredRequest::SharedDtor() {
+  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete answer_;
+  }
+  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete data_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ChallengeAnsweredRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ChallengeAnsweredRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChallengeAnsweredRequest_descriptor_;
+}
+
+const ChallengeAnsweredRequest& ChallengeAnsweredRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ChallengeAnsweredRequest* ChallengeAnsweredRequest::default_instance_ = NULL;
+
+ChallengeAnsweredRequest* ChallengeAnsweredRequest::New() const {
+  return new ChallengeAnsweredRequest;
+}
+
+void ChallengeAnsweredRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_answer()) {
+      if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        answer_->clear();
+      }
+    }
+    if (has_data()) {
+      if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        data_->clear();
+      }
+    }
+    id_ = 0u;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ChallengeAnsweredRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required string answer = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_answer()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->answer().data(), this->answer().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "answer");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_data;
+        break;
+      }
+
+      // optional bytes data = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_data:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_data()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_id;
+        break;
+      }
+
+      // optional uint32 id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
+  return false;
+#undef DO_
+}
+
+void ChallengeAnsweredRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
+  // required string answer = 1;
+  if (has_answer()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->answer().data(), this->answer().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "answer");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->answer(), output);
+  }
+
+  // optional bytes data = 2;
+  if (has_data()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->data(), output);
+  }
+
+  // optional uint32 id = 3;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
+}
+
+::google::protobuf::uint8* ChallengeAnsweredRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
+  // required string answer = 1;
+  if (has_answer()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->answer().data(), this->answer().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "answer");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->answer(), target);
+  }
+
+  // optional bytes data = 2;
+  if (has_data()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        2, this->data(), target);
+  }
+
+  // optional uint32 id = 3;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
+  return target;
+}
+
+int ChallengeAnsweredRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required string answer = 1;
+    if (has_answer()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->answer());
+    }
+
+    // optional bytes data = 2;
+    if (has_data()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->data());
+    }
+
+    // optional uint32 id = 3;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ChallengeAnsweredRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ChallengeAnsweredRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ChallengeAnsweredRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ChallengeAnsweredRequest::MergeFrom(const ChallengeAnsweredRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_answer()) {
+      set_answer(from.answer());
+    }
+    if (from.has_data()) {
+      set_data(from.data());
+    }
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ChallengeAnsweredRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ChallengeAnsweredRequest::CopyFrom(const ChallengeAnsweredRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChallengeAnsweredRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  return true;
+}
+
+void ChallengeAnsweredRequest::Swap(ChallengeAnsweredRequest* other) {
+  if (other != this) {
+    std::swap(answer_, other->answer_);
+    std::swap(data_, other->data_);
+    std::swap(id_, other->id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ChallengeAnsweredRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ChallengeAnsweredRequest_descriptor_;
+  metadata.reflection = ChallengeAnsweredRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ChallengeAnsweredResponse::kDataFieldNumber;
+const int ChallengeAnsweredResponse::kDoRetryFieldNumber;
+const int ChallengeAnsweredResponse::kRecordNotFoundFieldNumber;
+#endif  // !_MSC_VER
+
+ChallengeAnsweredResponse::ChallengeAnsweredResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
+}
+
+void ChallengeAnsweredResponse::InitAsDefaultInstance() {
+}
+
+ChallengeAnsweredResponse::ChallengeAnsweredResponse(const ChallengeAnsweredResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
+}
+
+void ChallengeAnsweredResponse::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  data_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  do_retry_ = false;
+  record_not_found_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ChallengeAnsweredResponse::~ChallengeAnsweredResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
+  SharedDtor();
+}
+
+void ChallengeAnsweredResponse::SharedDtor() {
+  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete data_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ChallengeAnsweredResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ChallengeAnsweredResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChallengeAnsweredResponse_descriptor_;
+}
+
+const ChallengeAnsweredResponse& ChallengeAnsweredResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ChallengeAnsweredResponse* ChallengeAnsweredResponse::default_instance_ = NULL;
+
+ChallengeAnsweredResponse* ChallengeAnsweredResponse::New() const {
+  return new ChallengeAnsweredResponse;
+}
+
+void ChallengeAnsweredResponse::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ChallengeAnsweredResponse*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(do_retry_, record_not_found_);
+    if (has_data()) {
+      if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        data_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ChallengeAnsweredResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bytes data = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_data()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_do_retry;
+        break;
+      }
+
+      // optional bool do_retry = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_do_retry:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &do_retry_)));
+          set_has_do_retry();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_record_not_found;
+        break;
+      }
+
+      // optional bool record_not_found = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_record_not_found:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &record_not_found_)));
+          set_has_record_not_found();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
+  return false;
+#undef DO_
+}
+
+void ChallengeAnsweredResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
+  // optional bytes data = 1;
+  if (has_data()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      1, this->data(), output);
+  }
+
+  // optional bool do_retry = 2;
+  if (has_do_retry()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->do_retry(), output);
+  }
+
+  // optional bool record_not_found = 3;
+  if (has_record_not_found()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->record_not_found(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
+}
+
+::google::protobuf::uint8* ChallengeAnsweredResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
+  // optional bytes data = 1;
+  if (has_data()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        1, this->data(), target);
+  }
+
+  // optional bool do_retry = 2;
+  if (has_do_retry()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->do_retry(), target);
+  }
+
+  // optional bool record_not_found = 3;
+  if (has_record_not_found()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->record_not_found(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
+  return target;
+}
+
+int ChallengeAnsweredResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bytes data = 1;
+    if (has_data()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->data());
+    }
+
+    // optional bool do_retry = 2;
+    if (has_do_retry()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool record_not_found = 3;
+    if (has_record_not_found()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ChallengeAnsweredResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ChallengeAnsweredResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ChallengeAnsweredResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ChallengeAnsweredResponse::MergeFrom(const ChallengeAnsweredResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_data()) {
+      set_data(from.data());
+    }
+    if (from.has_do_retry()) {
+      set_do_retry(from.do_retry());
+    }
+    if (from.has_record_not_found()) {
+      set_record_not_found(from.record_not_found());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ChallengeAnsweredResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ChallengeAnsweredResponse::CopyFrom(const ChallengeAnsweredResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChallengeAnsweredResponse::IsInitialized() const {
+
+  return true;
+}
+
+void ChallengeAnsweredResponse::Swap(ChallengeAnsweredResponse* other) {
+  if (other != this) {
+    std::swap(data_, other->data_);
+    std::swap(do_retry_, other->do_retry_);
+    std::swap(record_not_found_, other->record_not_found_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ChallengeAnsweredResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ChallengeAnsweredResponse_descriptor_;
+  metadata.reflection = ChallengeAnsweredResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ChallengeCancelledRequest::kIdFieldNumber;
+#endif  // !_MSC_VER
+
+ChallengeCancelledRequest::ChallengeCancelledRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
+}
+
+void ChallengeCancelledRequest::InitAsDefaultInstance() {
+}
+
+ChallengeCancelledRequest::ChallengeCancelledRequest(const ChallengeCancelledRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
+}
+
+void ChallengeCancelledRequest::SharedCtor() {
+  _cached_size_ = 0;
+  id_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ChallengeCancelledRequest::~ChallengeCancelledRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
+  SharedDtor();
+}
+
+void ChallengeCancelledRequest::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ChallengeCancelledRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ChallengeCancelledRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChallengeCancelledRequest_descriptor_;
+}
+
+const ChallengeCancelledRequest& ChallengeCancelledRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ChallengeCancelledRequest* ChallengeCancelledRequest::default_instance_ = NULL;
+
+ChallengeCancelledRequest* ChallengeCancelledRequest::New() const {
+  return new ChallengeCancelledRequest;
+}
+
+void ChallengeCancelledRequest::Clear() {
+  id_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ChallengeCancelledRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
+  return false;
+#undef DO_
+}
+
+void ChallengeCancelledRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
+  // optional uint32 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
+}
+
+::google::protobuf::uint8* ChallengeCancelledRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
+  // optional uint32 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
+  return target;
+}
+
+int ChallengeCancelledRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ChallengeCancelledRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ChallengeCancelledRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ChallengeCancelledRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ChallengeCancelledRequest::MergeFrom(const ChallengeCancelledRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ChallengeCancelledRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ChallengeCancelledRequest::CopyFrom(const ChallengeCancelledRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChallengeCancelledRequest::IsInitialized() const {
+
+  return true;
+}
+
+void ChallengeCancelledRequest::Swap(ChallengeCancelledRequest* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ChallengeCancelledRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ChallengeCancelledRequest_descriptor_;
+  metadata.reflection = ChallengeCancelledRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SendChallengeToUserRequest::kPeerIdFieldNumber;
+const int SendChallengeToUserRequest::kGameAccountIdFieldNumber;
+const int SendChallengeToUserRequest::kChallengesFieldNumber;
+const int SendChallengeToUserRequest::kContextFieldNumber;
+const int SendChallengeToUserRequest::kTimeoutFieldNumber;
+const int SendChallengeToUserRequest::kAttributesFieldNumber;
+const int SendChallengeToUserRequest::kHostFieldNumber;
+const int SendChallengeToUserRequest::kAccountIdFieldNumber;
+#endif  // !_MSC_VER
+
+SendChallengeToUserRequest::SendChallengeToUserRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
+}
+
+void SendChallengeToUserRequest::InitAsDefaultInstance() {
+  peer_id_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+SendChallengeToUserRequest::SendChallengeToUserRequest(const SendChallengeToUserRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
+}
+
+void SendChallengeToUserRequest::SharedCtor() {
+  _cached_size_ = 0;
+  peer_id_ = NULL;
+  game_account_id_ = NULL;
+  context_ = 0u;
+  timeout_ = GOOGLE_ULONGLONG(0);
+  host_ = NULL;
+  account_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SendChallengeToUserRequest::~SendChallengeToUserRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
+  SharedDtor();
+}
+
+void SendChallengeToUserRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete peer_id_;
+    delete game_account_id_;
+    delete host_;
+    delete account_id_;
+  }
+}
+
+void SendChallengeToUserRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SendChallengeToUserRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SendChallengeToUserRequest_descriptor_;
+}
+
+const SendChallengeToUserRequest& SendChallengeToUserRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SendChallengeToUserRequest* SendChallengeToUserRequest::default_instance_ = NULL;
+
+SendChallengeToUserRequest* SendChallengeToUserRequest::New() const {
+  return new SendChallengeToUserRequest;
+}
+
+void SendChallengeToUserRequest::Clear() {
+  if (_has_bits_[0 / 32] & 219) {
+    if (has_peer_id()) {
+      if (peer_id_ != NULL) peer_id_->::bgs::protocol::ProcessId::Clear();
+    }
+    if (has_game_account_id()) {
+      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    context_ = 0u;
+    timeout_ = GOOGLE_ULONGLONG(0);
+    if (has_host()) {
+      if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+    }
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  challenges_.Clear();
+  attributes_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SendChallengeToUserRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.ProcessId peer_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_peer_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_game_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId game_account_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_game_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_challenges;
+        break;
+      }
+
+      // repeated .bgs.protocol.challenge.v1.Challenge challenges = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_challenges:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_challenges()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_challenges;
+        if (input->ExpectTag(37)) goto parse_context;
+        break;
+      }
+
+      // required fixed32 context = 4;
+      case 4: {
+        if (tag == 37) {
+         parse_context:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &context_)));
+          set_has_context();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_timeout;
+        break;
+      }
+
+      // optional uint64 timeout = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_timeout:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &timeout_)));
+          set_has_timeout();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_attributes;
+        break;
+      }
+
+      // repeated .bgs.protocol.Attribute attributes = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_attributes:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attributes()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_attributes;
+        if (input->ExpectTag(58)) goto parse_host;
+        break;
+      }
+
+      // optional .bgs.protocol.ProcessId host = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_host:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_host()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId account_id = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
+  return false;
+#undef DO_
+}
+
+void SendChallengeToUserRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
+  // optional .bgs.protocol.ProcessId peer_id = 1;
+  if (has_peer_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->peer_id(), output);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->game_account_id(), output);
+  }
+
+  // repeated .bgs.protocol.challenge.v1.Challenge challenges = 3;
+  for (int i = 0; i < this->challenges_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->challenges(i), output);
+  }
+
+  // required fixed32 context = 4;
+  if (has_context()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->context(), output);
+  }
+
+  // optional uint64 timeout = 5;
+  if (has_timeout()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->timeout(), output);
+  }
+
+  // repeated .bgs.protocol.Attribute attributes = 6;
+  for (int i = 0; i < this->attributes_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->attributes(i), output);
+  }
+
+  // optional .bgs.protocol.ProcessId host = 7;
+  if (has_host()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      7, this->host(), output);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 8;
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      8, this->account_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
+}
+
+::google::protobuf::uint8* SendChallengeToUserRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
+  // optional .bgs.protocol.ProcessId peer_id = 1;
+  if (has_peer_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->peer_id(), target);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->game_account_id(), target);
+  }
+
+  // repeated .bgs.protocol.challenge.v1.Challenge challenges = 3;
+  for (int i = 0; i < this->challenges_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->challenges(i), target);
+  }
+
+  // required fixed32 context = 4;
+  if (has_context()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->context(), target);
+  }
+
+  // optional uint64 timeout = 5;
+  if (has_timeout()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->timeout(), target);
+  }
+
+  // repeated .bgs.protocol.Attribute attributes = 6;
+  for (int i = 0; i < this->attributes_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->attributes(i), target);
+  }
+
+  // optional .bgs.protocol.ProcessId host = 7;
+  if (has_host()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        7, this->host(), target);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 8;
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        8, this->account_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
+  return target;
+}
+
+int SendChallengeToUserRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.ProcessId peer_id = 1;
+    if (has_peer_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->peer_id());
+    }
+
+    // optional .bgs.protocol.EntityId game_account_id = 2;
+    if (has_game_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_id());
+    }
+
+    // required fixed32 context = 4;
+    if (has_context()) {
+      total_size += 1 + 4;
+    }
+
+    // optional uint64 timeout = 5;
+    if (has_timeout()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->timeout());
+    }
+
+    // optional .bgs.protocol.ProcessId host = 7;
+    if (has_host()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->host());
+    }
+
+    // optional .bgs.protocol.EntityId account_id = 8;
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+  }
+  // repeated .bgs.protocol.challenge.v1.Challenge challenges = 3;
+  total_size += 1 * this->challenges_size();
+  for (int i = 0; i < this->challenges_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->challenges(i));
+  }
+
+  // repeated .bgs.protocol.Attribute attributes = 6;
+  total_size += 1 * this->attributes_size();
+  for (int i = 0; i < this->attributes_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attributes(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SendChallengeToUserRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SendChallengeToUserRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SendChallengeToUserRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SendChallengeToUserRequest::MergeFrom(const SendChallengeToUserRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  challenges_.MergeFrom(from.challenges_);
+  attributes_.MergeFrom(from.attributes_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_peer_id()) {
+      mutable_peer_id()->::bgs::protocol::ProcessId::MergeFrom(from.peer_id());
+    }
+    if (from.has_game_account_id()) {
+      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+    }
+    if (from.has_context()) {
+      set_context(from.context());
+    }
+    if (from.has_timeout()) {
+      set_timeout(from.timeout());
+    }
+    if (from.has_host()) {
+      mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host());
+    }
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SendChallengeToUserRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SendChallengeToUserRequest::CopyFrom(const SendChallengeToUserRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SendChallengeToUserRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000008) != 0x00000008) return false;
+
+  if (has_peer_id()) {
+    if (!this->peer_id().IsInitialized()) return false;
+  }
+  if (has_game_account_id()) {
+    if (!this->game_account_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->challenges())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->attributes())) return false;
+  if (has_host()) {
+    if (!this->host().IsInitialized()) return false;
+  }
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SendChallengeToUserRequest::Swap(SendChallengeToUserRequest* other) {
+  if (other != this) {
+    std::swap(peer_id_, other->peer_id_);
+    std::swap(game_account_id_, other->game_account_id_);
+    challenges_.Swap(&other->challenges_);
+    std::swap(context_, other->context_);
+    std::swap(timeout_, other->timeout_);
+    attributes_.Swap(&other->attributes_);
+    std::swap(host_, other->host_);
+    std::swap(account_id_, other->account_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SendChallengeToUserRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SendChallengeToUserRequest_descriptor_;
+  metadata.reflection = SendChallengeToUserRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SendChallengeToUserResponse::kIdFieldNumber;
+#endif  // !_MSC_VER
+
+SendChallengeToUserResponse::SendChallengeToUserResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
+}
+
+void SendChallengeToUserResponse::InitAsDefaultInstance() {
+}
+
+SendChallengeToUserResponse::SendChallengeToUserResponse(const SendChallengeToUserResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
+}
+
+void SendChallengeToUserResponse::SharedCtor() {
+  _cached_size_ = 0;
+  id_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SendChallengeToUserResponse::~SendChallengeToUserResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
+  SharedDtor();
+}
+
+void SendChallengeToUserResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void SendChallengeToUserResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SendChallengeToUserResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SendChallengeToUserResponse_descriptor_;
+}
+
+const SendChallengeToUserResponse& SendChallengeToUserResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SendChallengeToUserResponse* SendChallengeToUserResponse::default_instance_ = NULL;
+
+SendChallengeToUserResponse* SendChallengeToUserResponse::New() const {
+  return new SendChallengeToUserResponse;
+}
+
+void SendChallengeToUserResponse::Clear() {
+  id_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SendChallengeToUserResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
+  return false;
+#undef DO_
+}
+
+void SendChallengeToUserResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
+  // optional uint32 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
+}
+
+::google::protobuf::uint8* SendChallengeToUserResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
+  // optional uint32 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
+  return target;
+}
+
+int SendChallengeToUserResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SendChallengeToUserResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SendChallengeToUserResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SendChallengeToUserResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SendChallengeToUserResponse::MergeFrom(const SendChallengeToUserResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SendChallengeToUserResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SendChallengeToUserResponse::CopyFrom(const SendChallengeToUserResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SendChallengeToUserResponse::IsInitialized() const {
+
+  return true;
+}
+
+void SendChallengeToUserResponse::Swap(SendChallengeToUserResponse* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SendChallengeToUserResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SendChallengeToUserResponse_descriptor_;
+  metadata.reflection = SendChallengeToUserResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ChallengeUserRequest::kChallengesFieldNumber;
+const int ChallengeUserRequest::kContextFieldNumber;
+const int ChallengeUserRequest::kIdFieldNumber;
+const int ChallengeUserRequest::kDeadlineFieldNumber;
+const int ChallengeUserRequest::kAttributesFieldNumber;
+const int ChallengeUserRequest::kGameAccountIdFieldNumber;
+#endif  // !_MSC_VER
+
+ChallengeUserRequest::ChallengeUserRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeUserRequest)
+}
+
+void ChallengeUserRequest::InitAsDefaultInstance() {
+  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+ChallengeUserRequest::ChallengeUserRequest(const ChallengeUserRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeUserRequest)
+}
+
+void ChallengeUserRequest::SharedCtor() {
+  _cached_size_ = 0;
+  context_ = 0u;
+  id_ = 0u;
+  deadline_ = GOOGLE_ULONGLONG(0);
+  game_account_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ChallengeUserRequest::~ChallengeUserRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeUserRequest)
+  SharedDtor();
+}
+
+void ChallengeUserRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete game_account_id_;
+  }
+}
+
+void ChallengeUserRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ChallengeUserRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChallengeUserRequest_descriptor_;
+}
+
+const ChallengeUserRequest& ChallengeUserRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ChallengeUserRequest* ChallengeUserRequest::default_instance_ = NULL;
+
+ChallengeUserRequest* ChallengeUserRequest::New() const {
+  return new ChallengeUserRequest;
+}
+
+void ChallengeUserRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ChallengeUserRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 46) {
+    ZR_(context_, deadline_);
+    if (has_game_account_id()) {
+      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  challenges_.Clear();
+  attributes_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ChallengeUserRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeUserRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.challenge.v1.Challenge challenges = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_challenges:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_challenges()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_challenges;
+        if (input->ExpectTag(21)) goto parse_context;
+        break;
+      }
+
+      // required fixed32 context = 2;
+      case 2: {
+        if (tag == 21) {
+         parse_context:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &context_)));
+          set_has_context();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_id;
+        break;
+      }
+
+      // optional uint32 id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_deadline;
+        break;
+      }
+
+      // optional uint64 deadline = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_deadline:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &deadline_)));
+          set_has_deadline();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_attributes;
+        break;
+      }
+
+      // repeated .bgs.protocol.Attribute attributes = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_attributes:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attributes()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_attributes;
+        if (input->ExpectTag(50)) goto parse_game_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId game_account_id = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_game_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.ChallengeUserRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeUserRequest)
+  return false;
+#undef DO_
+}
+
+void ChallengeUserRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeUserRequest)
+  // repeated .bgs.protocol.challenge.v1.Challenge challenges = 1;
+  for (int i = 0; i < this->challenges_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->challenges(i), output);
+  }
+
+  // required fixed32 context = 2;
+  if (has_context()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->context(), output);
+  }
+
+  // optional uint32 id = 3;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->id(), output);
+  }
+
+  // optional uint64 deadline = 4;
+  if (has_deadline()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->deadline(), output);
+  }
+
+  // repeated .bgs.protocol.Attribute attributes = 5;
+  for (int i = 0; i < this->attributes_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->attributes(i), output);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 6;
+  if (has_game_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->game_account_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeUserRequest)
+}
+
+::google::protobuf::uint8* ChallengeUserRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeUserRequest)
+  // repeated .bgs.protocol.challenge.v1.Challenge challenges = 1;
+  for (int i = 0; i < this->challenges_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->challenges(i), target);
+  }
+
+  // required fixed32 context = 2;
+  if (has_context()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->context(), target);
+  }
+
+  // optional uint32 id = 3;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->id(), target);
+  }
+
+  // optional uint64 deadline = 4;
+  if (has_deadline()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->deadline(), target);
+  }
+
+  // repeated .bgs.protocol.Attribute attributes = 5;
+  for (int i = 0; i < this->attributes_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->attributes(i), target);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 6;
+  if (has_game_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->game_account_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeUserRequest)
+  return target;
+}
+
+int ChallengeUserRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // required fixed32 context = 2;
+    if (has_context()) {
+      total_size += 1 + 4;
+    }
+
+    // optional uint32 id = 3;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->id());
+    }
+
+    // optional uint64 deadline = 4;
+    if (has_deadline()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->deadline());
+    }
+
+    // optional .bgs.protocol.EntityId game_account_id = 6;
+    if (has_game_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_id());
+    }
+
+  }
+  // repeated .bgs.protocol.challenge.v1.Challenge challenges = 1;
+  total_size += 1 * this->challenges_size();
+  for (int i = 0; i < this->challenges_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->challenges(i));
+  }
+
+  // repeated .bgs.protocol.Attribute attributes = 5;
+  total_size += 1 * this->attributes_size();
+  for (int i = 0; i < this->attributes_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attributes(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ChallengeUserRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ChallengeUserRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ChallengeUserRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ChallengeUserRequest::MergeFrom(const ChallengeUserRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  challenges_.MergeFrom(from.challenges_);
+  attributes_.MergeFrom(from.attributes_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_context()) {
+      set_context(from.context());
+    }
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_deadline()) {
+      set_deadline(from.deadline());
+    }
+    if (from.has_game_account_id()) {
+      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ChallengeUserRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ChallengeUserRequest::CopyFrom(const ChallengeUserRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChallengeUserRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->challenges())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->attributes())) return false;
+  if (has_game_account_id()) {
+    if (!this->game_account_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ChallengeUserRequest::Swap(ChallengeUserRequest* other) {
+  if (other != this) {
+    challenges_.Swap(&other->challenges_);
+    std::swap(context_, other->context_);
+    std::swap(id_, other->id_);
+    std::swap(deadline_, other->deadline_);
+    attributes_.Swap(&other->attributes_);
+    std::swap(game_account_id_, other->game_account_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ChallengeUserRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ChallengeUserRequest_descriptor_;
+  metadata.reflection = ChallengeUserRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ChallengeResultRequest::kIdFieldNumber;
+const int ChallengeResultRequest::kTypeFieldNumber;
+const int ChallengeResultRequest::kErrorIdFieldNumber;
+const int ChallengeResultRequest::kAnswerFieldNumber;
+#endif  // !_MSC_VER
+
+ChallengeResultRequest::ChallengeResultRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeResultRequest)
+}
+
+void ChallengeResultRequest::InitAsDefaultInstance() {
+}
+
+ChallengeResultRequest::ChallengeResultRequest(const ChallengeResultRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeResultRequest)
+}
+
+void ChallengeResultRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = 0u;
+  type_ = 0u;
+  error_id_ = 0u;
+  answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ChallengeResultRequest::~ChallengeResultRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeResultRequest)
+  SharedDtor();
+}
+
+void ChallengeResultRequest::SharedDtor() {
+  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete answer_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ChallengeResultRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ChallengeResultRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChallengeResultRequest_descriptor_;
+}
+
+const ChallengeResultRequest& ChallengeResultRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ChallengeResultRequest* ChallengeResultRequest::default_instance_ = NULL;
+
+ChallengeResultRequest* ChallengeResultRequest::New() const {
+  return new ChallengeResultRequest;
+}
+
+void ChallengeResultRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ChallengeResultRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(id_, type_);
+    error_id_ = 0u;
+    if (has_answer()) {
+      if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        answer_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ChallengeResultRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeResultRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(21)) goto parse_type;
+        break;
+      }
+
+      // optional fixed32 type = 2;
+      case 2: {
+        if (tag == 21) {
+         parse_type:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &type_)));
+          set_has_type();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_error_id;
+        break;
+      }
+
+      // optional uint32 error_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_error_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &error_id_)));
+          set_has_error_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_answer;
+        break;
+      }
+
+      // optional bytes answer = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_answer:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_answer()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.ChallengeResultRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeResultRequest)
+  return false;
+#undef DO_
+}
+
+void ChallengeResultRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeResultRequest)
+  // optional uint32 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output);
+  }
+
+  // optional fixed32 type = 2;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->type(), output);
+  }
+
+  // optional uint32 error_id = 3;
+  if (has_error_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->error_id(), output);
+  }
+
+  // optional bytes answer = 4;
+  if (has_answer()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      4, this->answer(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeResultRequest)
+}
+
+::google::protobuf::uint8* ChallengeResultRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeResultRequest)
+  // optional uint32 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target);
+  }
+
+  // optional fixed32 type = 2;
+  if (has_type()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->type(), target);
+  }
+
+  // optional uint32 error_id = 3;
+  if (has_error_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->error_id(), target);
+  }
+
+  // optional bytes answer = 4;
+  if (has_answer()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        4, this->answer(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeResultRequest)
+  return target;
+}
+
+int ChallengeResultRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->id());
+    }
+
+    // optional fixed32 type = 2;
+    if (has_type()) {
+      total_size += 1 + 4;
+    }
+
+    // optional uint32 error_id = 3;
+    if (has_error_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->error_id());
+    }
+
+    // optional bytes answer = 4;
+    if (has_answer()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->answer());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ChallengeResultRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ChallengeResultRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ChallengeResultRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ChallengeResultRequest::MergeFrom(const ChallengeResultRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_error_id()) {
+      set_error_id(from.error_id());
+    }
+    if (from.has_answer()) {
+      set_answer(from.answer());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ChallengeResultRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ChallengeResultRequest::CopyFrom(const ChallengeResultRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChallengeResultRequest::IsInitialized() const {
+
+  return true;
+}
+
+void ChallengeResultRequest::Swap(ChallengeResultRequest* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(type_, other->type_);
+    std::swap(error_id_, other->error_id_);
+    std::swap(answer_, other->answer_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ChallengeResultRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ChallengeResultRequest_descriptor_;
+  metadata.reflection = ChallengeResultRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ChallengeExternalRequest::kRequestTokenFieldNumber;
+const int ChallengeExternalRequest::kPayloadTypeFieldNumber;
+const int ChallengeExternalRequest::kPayloadFieldNumber;
+#endif  // !_MSC_VER
+
+ChallengeExternalRequest::ChallengeExternalRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeExternalRequest)
+}
+
+void ChallengeExternalRequest::InitAsDefaultInstance() {
+}
+
+ChallengeExternalRequest::ChallengeExternalRequest(const ChallengeExternalRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeExternalRequest)
+}
+
+void ChallengeExternalRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  request_token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  payload_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ChallengeExternalRequest::~ChallengeExternalRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeExternalRequest)
+  SharedDtor();
+}
+
+void ChallengeExternalRequest::SharedDtor() {
+  if (request_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete request_token_;
+  }
+  if (payload_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete payload_type_;
+  }
+  if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete payload_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ChallengeExternalRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ChallengeExternalRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChallengeExternalRequest_descriptor_;
+}
+
+const ChallengeExternalRequest& ChallengeExternalRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ChallengeExternalRequest* ChallengeExternalRequest::default_instance_ = NULL;
+
+ChallengeExternalRequest* ChallengeExternalRequest::New() const {
+  return new ChallengeExternalRequest;
+}
+
+void ChallengeExternalRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_request_token()) {
+      if (request_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        request_token_->clear();
+      }
+    }
+    if (has_payload_type()) {
+      if (payload_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        payload_type_->clear();
+      }
+    }
+    if (has_payload()) {
+      if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        payload_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ChallengeExternalRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeExternalRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string request_token = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_request_token()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->request_token().data(), this->request_token().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "request_token");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_payload_type;
+        break;
+      }
+
+      // optional string payload_type = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_payload_type:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_payload_type()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->payload_type().data(), this->payload_type().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "payload_type");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_payload;
+        break;
+      }
+
+      // optional bytes payload = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_payload:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_payload()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.ChallengeExternalRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeExternalRequest)
+  return false;
+#undef DO_
+}
+
+void ChallengeExternalRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeExternalRequest)
+  // optional string request_token = 1;
+  if (has_request_token()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->request_token().data(), this->request_token().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "request_token");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->request_token(), output);
+  }
+
+  // optional string payload_type = 2;
+  if (has_payload_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->payload_type().data(), this->payload_type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "payload_type");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->payload_type(), output);
+  }
+
+  // optional bytes payload = 3;
+  if (has_payload()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      3, this->payload(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeExternalRequest)
+}
+
+::google::protobuf::uint8* ChallengeExternalRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeExternalRequest)
+  // optional string request_token = 1;
+  if (has_request_token()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->request_token().data(), this->request_token().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "request_token");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->request_token(), target);
+  }
+
+  // optional string payload_type = 2;
+  if (has_payload_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->payload_type().data(), this->payload_type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "payload_type");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->payload_type(), target);
+  }
+
+  // optional bytes payload = 3;
+  if (has_payload()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        3, this->payload(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeExternalRequest)
+  return target;
+}
+
+int ChallengeExternalRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string request_token = 1;
+    if (has_request_token()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->request_token());
+    }
+
+    // optional string payload_type = 2;
+    if (has_payload_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->payload_type());
+    }
+
+    // optional bytes payload = 3;
+    if (has_payload()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->payload());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ChallengeExternalRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ChallengeExternalRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ChallengeExternalRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ChallengeExternalRequest::MergeFrom(const ChallengeExternalRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_request_token()) {
+      set_request_token(from.request_token());
+    }
+    if (from.has_payload_type()) {
+      set_payload_type(from.payload_type());
+    }
+    if (from.has_payload()) {
+      set_payload(from.payload());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ChallengeExternalRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ChallengeExternalRequest::CopyFrom(const ChallengeExternalRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChallengeExternalRequest::IsInitialized() const {
+
+  return true;
+}
+
+void ChallengeExternalRequest::Swap(ChallengeExternalRequest* other) {
+  if (other != this) {
+    std::swap(request_token_, other->request_token_);
+    std::swap(payload_type_, other->payload_type_);
+    std::swap(payload_, other->payload_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ChallengeExternalRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ChallengeExternalRequest_descriptor_;
+  metadata.reflection = ChallengeExternalRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ChallengeExternalResult::kRequestTokenFieldNumber;
+const int ChallengeExternalResult::kPassedFieldNumber;
+#endif  // !_MSC_VER
+
+ChallengeExternalResult::ChallengeExternalResult()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.challenge.v1.ChallengeExternalResult)
+}
+
+void ChallengeExternalResult::InitAsDefaultInstance() {
+}
+
+ChallengeExternalResult::ChallengeExternalResult(const ChallengeExternalResult& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.challenge.v1.ChallengeExternalResult)
+}
+
+void ChallengeExternalResult::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  request_token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  passed_ = true;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ChallengeExternalResult::~ChallengeExternalResult() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.challenge.v1.ChallengeExternalResult)
+  SharedDtor();
+}
+
+void ChallengeExternalResult::SharedDtor() {
+  if (request_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete request_token_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ChallengeExternalResult::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ChallengeExternalResult::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChallengeExternalResult_descriptor_;
+}
+
+const ChallengeExternalResult& ChallengeExternalResult::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_challenge_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ChallengeExternalResult* ChallengeExternalResult::default_instance_ = NULL;
+
+ChallengeExternalResult* ChallengeExternalResult::New() const {
+  return new ChallengeExternalResult;
+}
+
+void ChallengeExternalResult::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_request_token()) {
+      if (request_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        request_token_->clear();
+      }
+    }
+    passed_ = true;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ChallengeExternalResult::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.challenge.v1.ChallengeExternalResult)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string request_token = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_request_token()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->request_token().data(), this->request_token().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "request_token");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_passed;
+        break;
+      }
+
+      // optional bool passed = 2 [default = true];
+      case 2: {
+        if (tag == 16) {
+         parse_passed:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &passed_)));
+          set_has_passed();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.challenge.v1.ChallengeExternalResult)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.challenge.v1.ChallengeExternalResult)
+  return false;
+#undef DO_
+}
+
+void ChallengeExternalResult::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.challenge.v1.ChallengeExternalResult)
+  // optional string request_token = 1;
+  if (has_request_token()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->request_token().data(), this->request_token().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "request_token");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->request_token(), output);
+  }
+
+  // optional bool passed = 2 [default = true];
+  if (has_passed()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->passed(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.challenge.v1.ChallengeExternalResult)
+}
+
+::google::protobuf::uint8* ChallengeExternalResult::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.challenge.v1.ChallengeExternalResult)
+  // optional string request_token = 1;
+  if (has_request_token()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->request_token().data(), this->request_token().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "request_token");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->request_token(), target);
+  }
+
+  // optional bool passed = 2 [default = true];
+  if (has_passed()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->passed(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.challenge.v1.ChallengeExternalResult)
+  return target;
+}
+
+int ChallengeExternalResult::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string request_token = 1;
+    if (has_request_token()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->request_token());
+    }
+
+    // optional bool passed = 2 [default = true];
+    if (has_passed()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ChallengeExternalResult::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ChallengeExternalResult* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ChallengeExternalResult*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ChallengeExternalResult::MergeFrom(const ChallengeExternalResult& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_request_token()) {
+      set_request_token(from.request_token());
+    }
+    if (from.has_passed()) {
+      set_passed(from.passed());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ChallengeExternalResult::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ChallengeExternalResult::CopyFrom(const ChallengeExternalResult& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChallengeExternalResult::IsInitialized() const {
+
+  return true;
+}
+
+void ChallengeExternalResult::Swap(ChallengeExternalResult* other) {
+  if (other != this) {
+    std::swap(request_token_, other->request_token_);
+    std::swap(passed_, other->passed_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ChallengeExternalResult::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ChallengeExternalResult_descriptor_;
+  metadata.reflection = ChallengeExternalResult_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* ChallengeService::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChallengeService_descriptor_;
+}
+
+void ChallengeService::ChallengePicked(::bgs::protocol::challenge::v1::ChallengePickedRequest const* request, std::function<void(::bgs::protocol::challenge::v1::ChallengePickedResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeService.ChallengePicked(bgs.protocol.challenge.v1.ChallengePickedRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::challenge::v1::ChallengePickedResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ChallengeService::ChallengeAnswered(::bgs::protocol::challenge::v1::ChallengeAnsweredRequest const* request, std::function<void(::bgs::protocol::challenge::v1::ChallengeAnsweredResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeService.ChallengeAnswered(bgs.protocol.challenge.v1.ChallengeAnsweredRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 2, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::challenge::v1::ChallengeAnsweredResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ChallengeService::ChallengeCancelled(::bgs::protocol::challenge::v1::ChallengeCancelledRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeService.ChallengeCancelled(bgs.protocol.challenge.v1.ChallengeCancelledRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 3, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ChallengeService::SendChallengeToUser(::bgs::protocol::challenge::v1::SendChallengeToUserRequest const* request, std::function<void(::bgs::protocol::challenge::v1::SendChallengeToUserResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeService.SendChallengeToUser(bgs.protocol.challenge.v1.SendChallengeToUserRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 4, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::challenge::v1::SendChallengeToUserResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ChallengeService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::challenge::v1::ChallengePickedRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeService.ChallengePicked server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::challenge::v1::ChallengePickedResponse response;
+      uint32 status = HandleChallengePicked(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeService.ChallengePicked(bgs.protocol.challenge.v1.ChallengePickedRequest{ %s }) returned bgs.protocol.challenge.v1.ChallengePickedResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 1, token, &response);
+      else
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    case 2: {
+      ::bgs::protocol::challenge::v1::ChallengeAnsweredRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeService.ChallengeAnswered server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::challenge::v1::ChallengeAnsweredResponse response;
+      uint32 status = HandleChallengeAnswered(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeService.ChallengeAnswered(bgs.protocol.challenge.v1.ChallengeAnsweredRequest{ %s }) returned bgs.protocol.challenge.v1.ChallengeAnsweredResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 2, token, &response);
+      else
+        SendResponse(service_hash_, 2, token, status);
+      break;
+    }
+    case 3: {
+      ::bgs::protocol::challenge::v1::ChallengeCancelledRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeService.ChallengeCancelled server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleChallengeCancelled(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeService.ChallengeCancelled(bgs.protocol.challenge.v1.ChallengeCancelledRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 3, token, &response);
+      else
+        SendResponse(service_hash_, 3, token, status);
+      break;
+    }
+    case 4: {
+      ::bgs::protocol::challenge::v1::SendChallengeToUserRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeService.SendChallengeToUser server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::challenge::v1::SendChallengeToUserResponse response;
+      uint32 status = HandleSendChallengeToUser(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeService.SendChallengeToUser(bgs.protocol.challenge.v1.SendChallengeToUserRequest{ %s }) returned bgs.protocol.challenge.v1.SendChallengeToUserResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 4, token, &response);
+      else
+        SendResponse(service_hash_, 4, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 ChallengeService::HandleChallengePicked(::bgs::protocol::challenge::v1::ChallengePickedRequest const* request, ::bgs::protocol::challenge::v1::ChallengePickedResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeService.ChallengePicked({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChallengeService::HandleChallengeAnswered(::bgs::protocol::challenge::v1::ChallengeAnsweredRequest const* request, ::bgs::protocol::challenge::v1::ChallengeAnsweredResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeService.ChallengeAnswered({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChallengeService::HandleChallengeCancelled(::bgs::protocol::challenge::v1::ChallengeCancelledRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeService.ChallengeCancelled({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChallengeService::HandleSendChallengeToUser(::bgs::protocol::challenge::v1::SendChallengeToUserRequest const* request, ::bgs::protocol::challenge::v1::SendChallengeToUserResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeService.SendChallengeToUser({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* ChallengeListener::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChallengeListener_descriptor_;
+}
+
+void ChallengeListener::OnChallengeUser(::bgs::protocol::challenge::v1::ChallengeUserRequest const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeListener.OnChallengeUser(bgs.protocol.challenge.v1.ChallengeUserRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request);
+}
+
+void ChallengeListener::OnChallengeResult(::bgs::protocol::challenge::v1::ChallengeResultRequest const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeListener.OnChallengeResult(bgs.protocol.challenge.v1.ChallengeResultRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 2, request);
+}
+
+void ChallengeListener::OnExternalChallenge(::bgs::protocol::challenge::v1::ChallengeExternalRequest const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeListener.OnExternalChallenge(bgs.protocol.challenge.v1.ChallengeExternalRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 3, request);
+}
+
+void ChallengeListener::OnExternalChallengeResult(::bgs::protocol::challenge::v1::ChallengeExternalResult const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChallengeListener.OnExternalChallengeResult(bgs.protocol.challenge.v1.ChallengeExternalResult{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 4, request);
+}
+
+void ChallengeListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::challenge::v1::ChallengeUserRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeListener.OnChallengeUser server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnChallengeUser(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeListener.OnChallengeUser(bgs.protocol.challenge.v1.ChallengeUserRequest{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    case 2: {
+      ::bgs::protocol::challenge::v1::ChallengeResultRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeListener.OnChallengeResult server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnChallengeResult(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeListener.OnChallengeResult(bgs.protocol.challenge.v1.ChallengeResultRequest{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 2, token, status);
+      break;
+    }
+    case 3: {
+      ::bgs::protocol::challenge::v1::ChallengeExternalRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeListener.OnExternalChallenge server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnExternalChallenge(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeListener.OnExternalChallenge(bgs.protocol.challenge.v1.ChallengeExternalRequest{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 3, token, status);
+      break;
+    }
+    case 4: {
+      ::bgs::protocol::challenge::v1::ChallengeExternalResult request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChallengeListener.OnExternalChallengeResult server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnExternalChallengeResult(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChallengeListener.OnExternalChallengeResult(bgs.protocol.challenge.v1.ChallengeExternalResult{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 4, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 ChallengeListener::HandleOnChallengeUser(::bgs::protocol::challenge::v1::ChallengeUserRequest const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeListener.OnChallengeUser({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChallengeListener::HandleOnChallengeResult(::bgs::protocol::challenge::v1::ChallengeResultRequest const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeListener.OnChallengeResult({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChallengeListener::HandleOnExternalChallenge(::bgs::protocol::challenge::v1::ChallengeExternalRequest const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeListener.OnExternalChallenge({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChallengeListener::HandleOnExternalChallengeResult(::bgs::protocol::challenge::v1::ChallengeExternalResult const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChallengeListener.OnExternalChallengeResult({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace challenge
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/challenge_service.pb.h b/src/server/proto/Client/challenge_service.pb.h
new file mode 100644
index 00000000000..0451375d46d
--- /dev/null
+++ b/src/server/proto/Client/challenge_service.pb.h
@@ -0,0 +1,3113 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: challenge_service.proto
+
+#ifndef PROTOBUF_challenge_5fservice_2eproto__INCLUDED
+#define PROTOBUF_challenge_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 "attribute_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 challenge {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto();
+void protobuf_AssignDesc_challenge_5fservice_2eproto();
+void protobuf_ShutdownFile_challenge_5fservice_2eproto();
+
+class Challenge;
+class ChallengePickedRequest;
+class ChallengePickedResponse;
+class ChallengeAnsweredRequest;
+class ChallengeAnsweredResponse;
+class ChallengeCancelledRequest;
+class SendChallengeToUserRequest;
+class SendChallengeToUserResponse;
+class ChallengeUserRequest;
+class ChallengeResultRequest;
+class ChallengeExternalRequest;
+class ChallengeExternalResult;
+
+// ===================================================================
+
+class TC_SHARED_API Challenge : public ::google::protobuf::Message {
+ public:
+  Challenge();
+  virtual ~Challenge();
+
+  Challenge(const Challenge& from);
+
+  inline Challenge& operator=(const Challenge& 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 Challenge& default_instance();
+
+  void Swap(Challenge* other);
+
+  // implements Message ----------------------------------------------
+
+  Challenge* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Challenge& from);
+  void MergeFrom(const Challenge& 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 fixed32 type = 1;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 1;
+  inline ::google::protobuf::uint32 type() const;
+  inline void set_type(::google::protobuf::uint32 value);
+
+  // optional string info = 2;
+  inline bool has_info() const;
+  inline void clear_info();
+  static const int kInfoFieldNumber = 2;
+  inline const ::std::string& info() const;
+  inline void set_info(const ::std::string& value);
+  inline void set_info(const char* value);
+  inline void set_info(const char* value, size_t size);
+  inline ::std::string* mutable_info();
+  inline ::std::string* release_info();
+  inline void set_allocated_info(::std::string* info);
+
+  // optional string answer = 3;
+  inline bool has_answer() const;
+  inline void clear_answer();
+  static const int kAnswerFieldNumber = 3;
+  inline const ::std::string& answer() const;
+  inline void set_answer(const ::std::string& value);
+  inline void set_answer(const char* value);
+  inline void set_answer(const char* value, size_t size);
+  inline ::std::string* mutable_answer();
+  inline ::std::string* release_answer();
+  inline void set_allocated_answer(::std::string* answer);
+
+  // optional uint32 retries = 4;
+  inline bool has_retries() const;
+  inline void clear_retries();
+  static const int kRetriesFieldNumber = 4;
+  inline ::google::protobuf::uint32 retries() const;
+  inline void set_retries(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.Challenge)
+ private:
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_info();
+  inline void clear_has_info();
+  inline void set_has_answer();
+  inline void clear_has_answer();
+  inline void set_has_retries();
+  inline void clear_has_retries();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* info_;
+  ::google::protobuf::uint32 type_;
+  ::google::protobuf::uint32 retries_;
+  ::std::string* answer_;
+  friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto();
+  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static Challenge* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ChallengePickedRequest : public ::google::protobuf::Message {
+ public:
+  ChallengePickedRequest();
+  virtual ~ChallengePickedRequest();
+
+  ChallengePickedRequest(const ChallengePickedRequest& from);
+
+  inline ChallengePickedRequest& operator=(const ChallengePickedRequest& 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 ChallengePickedRequest& default_instance();
+
+  void Swap(ChallengePickedRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ChallengePickedRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ChallengePickedRequest& from);
+  void MergeFrom(const ChallengePickedRequest& 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 fixed32 challenge = 1;
+  inline bool has_challenge() const;
+  inline void clear_challenge();
+  static const int kChallengeFieldNumber = 1;
+  inline ::google::protobuf::uint32 challenge() const;
+  inline void set_challenge(::google::protobuf::uint32 value);
+
+  // optional uint32 id = 2;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 2;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // optional bool new_challenge_protocol = 3 [default = false];
+  inline bool has_new_challenge_protocol() const;
+  inline void clear_new_challenge_protocol();
+  static const int kNewChallengeProtocolFieldNumber = 3;
+  inline bool new_challenge_protocol() const;
+  inline void set_new_challenge_protocol(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengePickedRequest)
+ private:
+  inline void set_has_challenge();
+  inline void clear_has_challenge();
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_new_challenge_protocol();
+  inline void clear_has_new_challenge_protocol();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 challenge_;
+  ::google::protobuf::uint32 id_;
+  bool new_challenge_protocol_;
+  friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto();
+  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ChallengePickedRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ChallengePickedResponse : public ::google::protobuf::Message {
+ public:
+  ChallengePickedResponse();
+  virtual ~ChallengePickedResponse();
+
+  ChallengePickedResponse(const ChallengePickedResponse& from);
+
+  inline ChallengePickedResponse& operator=(const ChallengePickedResponse& 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 ChallengePickedResponse& default_instance();
+
+  void Swap(ChallengePickedResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  ChallengePickedResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ChallengePickedResponse& from);
+  void MergeFrom(const ChallengePickedResponse& 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 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.challenge.v1.ChallengePickedResponse)
+ 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_challenge_5fservice_2eproto();
+  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ChallengePickedResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ChallengeAnsweredRequest : public ::google::protobuf::Message {
+ public:
+  ChallengeAnsweredRequest();
+  virtual ~ChallengeAnsweredRequest();
+
+  ChallengeAnsweredRequest(const ChallengeAnsweredRequest& from);
+
+  inline ChallengeAnsweredRequest& operator=(const ChallengeAnsweredRequest& 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 ChallengeAnsweredRequest& default_instance();
+
+  void Swap(ChallengeAnsweredRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ChallengeAnsweredRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ChallengeAnsweredRequest& from);
+  void MergeFrom(const ChallengeAnsweredRequest& 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 string answer = 1;
+  inline bool has_answer() const;
+  inline void clear_answer();
+  static const int kAnswerFieldNumber = 1;
+  inline const ::std::string& answer() const;
+  inline void set_answer(const ::std::string& value);
+  inline void set_answer(const char* value);
+  inline void set_answer(const char* value, size_t size);
+  inline ::std::string* mutable_answer();
+  inline ::std::string* release_answer();
+  inline void set_allocated_answer(::std::string* answer);
+
+  // optional bytes data = 2;
+  inline bool has_data() const;
+  inline void clear_data();
+  static const int kDataFieldNumber = 2;
+  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);
+
+  // optional uint32 id = 3;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 3;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeAnsweredRequest)
+ private:
+  inline void set_has_answer();
+  inline void clear_has_answer();
+  inline void set_has_data();
+  inline void clear_has_data();
+  inline void set_has_id();
+  inline void clear_has_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* answer_;
+  ::std::string* data_;
+  ::google::protobuf::uint32 id_;
+  friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto();
+  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ChallengeAnsweredRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ChallengeAnsweredResponse : public ::google::protobuf::Message {
+ public:
+  ChallengeAnsweredResponse();
+  virtual ~ChallengeAnsweredResponse();
+
+  ChallengeAnsweredResponse(const ChallengeAnsweredResponse& from);
+
+  inline ChallengeAnsweredResponse& operator=(const ChallengeAnsweredResponse& 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 ChallengeAnsweredResponse& default_instance();
+
+  void Swap(ChallengeAnsweredResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  ChallengeAnsweredResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ChallengeAnsweredResponse& from);
+  void MergeFrom(const ChallengeAnsweredResponse& 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 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);
+
+  // optional bool do_retry = 2;
+  inline bool has_do_retry() const;
+  inline void clear_do_retry();
+  static const int kDoRetryFieldNumber = 2;
+  inline bool do_retry() const;
+  inline void set_do_retry(bool value);
+
+  // optional bool record_not_found = 3;
+  inline bool has_record_not_found() const;
+  inline void clear_record_not_found();
+  static const int kRecordNotFoundFieldNumber = 3;
+  inline bool record_not_found() const;
+  inline void set_record_not_found(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeAnsweredResponse)
+ private:
+  inline void set_has_data();
+  inline void clear_has_data();
+  inline void set_has_do_retry();
+  inline void clear_has_do_retry();
+  inline void set_has_record_not_found();
+  inline void clear_has_record_not_found();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* data_;
+  bool do_retry_;
+  bool record_not_found_;
+  friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto();
+  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ChallengeAnsweredResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ChallengeCancelledRequest : public ::google::protobuf::Message {
+ public:
+  ChallengeCancelledRequest();
+  virtual ~ChallengeCancelledRequest();
+
+  ChallengeCancelledRequest(const ChallengeCancelledRequest& from);
+
+  inline ChallengeCancelledRequest& operator=(const ChallengeCancelledRequest& 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 ChallengeCancelledRequest& default_instance();
+
+  void Swap(ChallengeCancelledRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ChallengeCancelledRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ChallengeCancelledRequest& from);
+  void MergeFrom(const ChallengeCancelledRequest& 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 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeCancelledRequest)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 id_;
+  friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto();
+  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ChallengeCancelledRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API SendChallengeToUserRequest : public ::google::protobuf::Message {
+ public:
+  SendChallengeToUserRequest();
+  virtual ~SendChallengeToUserRequest();
+
+  SendChallengeToUserRequest(const SendChallengeToUserRequest& from);
+
+  inline SendChallengeToUserRequest& operator=(const SendChallengeToUserRequest& 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 SendChallengeToUserRequest& default_instance();
+
+  void Swap(SendChallengeToUserRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SendChallengeToUserRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SendChallengeToUserRequest& from);
+  void MergeFrom(const SendChallengeToUserRequest& 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.ProcessId peer_id = 1;
+  inline bool has_peer_id() const;
+  inline void clear_peer_id();
+  static const int kPeerIdFieldNumber = 1;
+  inline const ::bgs::protocol::ProcessId& peer_id() const;
+  inline ::bgs::protocol::ProcessId* mutable_peer_id();
+  inline ::bgs::protocol::ProcessId* release_peer_id();
+  inline void set_allocated_peer_id(::bgs::protocol::ProcessId* peer_id);
+
+  // 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);
+
+  // repeated .bgs.protocol.challenge.v1.Challenge challenges = 3;
+  inline int challenges_size() const;
+  inline void clear_challenges();
+  static const int kChallengesFieldNumber = 3;
+  inline const ::bgs::protocol::challenge::v1::Challenge& challenges(int index) const;
+  inline ::bgs::protocol::challenge::v1::Challenge* mutable_challenges(int index);
+  inline ::bgs::protocol::challenge::v1::Challenge* add_challenges();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >&
+      challenges() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >*
+      mutable_challenges();
+
+  // required fixed32 context = 4;
+  inline bool has_context() const;
+  inline void clear_context();
+  static const int kContextFieldNumber = 4;
+  inline ::google::protobuf::uint32 context() const;
+  inline void set_context(::google::protobuf::uint32 value);
+
+  // optional uint64 timeout = 5;
+  inline bool has_timeout() const;
+  inline void clear_timeout();
+  static const int kTimeoutFieldNumber = 5;
+  inline ::google::protobuf::uint64 timeout() const;
+  inline void set_timeout(::google::protobuf::uint64 value);
+
+  // repeated .bgs.protocol.Attribute attributes = 6;
+  inline int attributes_size() const;
+  inline void clear_attributes();
+  static const int kAttributesFieldNumber = 6;
+  inline const ::bgs::protocol::Attribute& attributes(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attributes(int index);
+  inline ::bgs::protocol::Attribute* add_attributes();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attributes() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attributes();
+
+  // optional .bgs.protocol.ProcessId host = 7;
+  inline bool has_host() const;
+  inline void clear_host();
+  static const int kHostFieldNumber = 7;
+  inline const ::bgs::protocol::ProcessId& host() const;
+  inline ::bgs::protocol::ProcessId* mutable_host();
+  inline ::bgs::protocol::ProcessId* release_host();
+  inline void set_allocated_host(::bgs::protocol::ProcessId* host);
+
+  // optional .bgs.protocol.EntityId account_id = 8;
+  inline bool has_account_id() const;
+  inline void clear_account_id();
+  static const int kAccountIdFieldNumber = 8;
+  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);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.SendChallengeToUserRequest)
+ private:
+  inline void set_has_peer_id();
+  inline void clear_has_peer_id();
+  inline void set_has_game_account_id();
+  inline void clear_has_game_account_id();
+  inline void set_has_context();
+  inline void clear_has_context();
+  inline void set_has_timeout();
+  inline void clear_has_timeout();
+  inline void set_has_host();
+  inline void clear_has_host();
+  inline void set_has_account_id();
+  inline void clear_has_account_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::ProcessId* peer_id_;
+  ::bgs::protocol::EntityId* game_account_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge > challenges_;
+  ::google::protobuf::uint64 timeout_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attributes_;
+  ::bgs::protocol::ProcessId* host_;
+  ::bgs::protocol::EntityId* account_id_;
+  ::google::protobuf::uint32 context_;
+  friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto();
+  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SendChallengeToUserRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API SendChallengeToUserResponse : public ::google::protobuf::Message {
+ public:
+  SendChallengeToUserResponse();
+  virtual ~SendChallengeToUserResponse();
+
+  SendChallengeToUserResponse(const SendChallengeToUserResponse& from);
+
+  inline SendChallengeToUserResponse& operator=(const SendChallengeToUserResponse& 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 SendChallengeToUserResponse& default_instance();
+
+  void Swap(SendChallengeToUserResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  SendChallengeToUserResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SendChallengeToUserResponse& from);
+  void MergeFrom(const SendChallengeToUserResponse& 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 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.SendChallengeToUserResponse)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 id_;
+  friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto();
+  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SendChallengeToUserResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ChallengeUserRequest : public ::google::protobuf::Message {
+ public:
+  ChallengeUserRequest();
+  virtual ~ChallengeUserRequest();
+
+  ChallengeUserRequest(const ChallengeUserRequest& from);
+
+  inline ChallengeUserRequest& operator=(const ChallengeUserRequest& 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 ChallengeUserRequest& default_instance();
+
+  void Swap(ChallengeUserRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ChallengeUserRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ChallengeUserRequest& from);
+  void MergeFrom(const ChallengeUserRequest& 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.challenge.v1.Challenge challenges = 1;
+  inline int challenges_size() const;
+  inline void clear_challenges();
+  static const int kChallengesFieldNumber = 1;
+  inline const ::bgs::protocol::challenge::v1::Challenge& challenges(int index) const;
+  inline ::bgs::protocol::challenge::v1::Challenge* mutable_challenges(int index);
+  inline ::bgs::protocol::challenge::v1::Challenge* add_challenges();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >&
+      challenges() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >*
+      mutable_challenges();
+
+  // required fixed32 context = 2;
+  inline bool has_context() const;
+  inline void clear_context();
+  static const int kContextFieldNumber = 2;
+  inline ::google::protobuf::uint32 context() const;
+  inline void set_context(::google::protobuf::uint32 value);
+
+  // optional uint32 id = 3;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 3;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // optional uint64 deadline = 4;
+  inline bool has_deadline() const;
+  inline void clear_deadline();
+  static const int kDeadlineFieldNumber = 4;
+  inline ::google::protobuf::uint64 deadline() const;
+  inline void set_deadline(::google::protobuf::uint64 value);
+
+  // repeated .bgs.protocol.Attribute attributes = 5;
+  inline int attributes_size() const;
+  inline void clear_attributes();
+  static const int kAttributesFieldNumber = 5;
+  inline const ::bgs::protocol::Attribute& attributes(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attributes(int index);
+  inline ::bgs::protocol::Attribute* add_attributes();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attributes() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attributes();
+
+  // optional .bgs.protocol.EntityId game_account_id = 6;
+  inline bool has_game_account_id() const;
+  inline void clear_game_account_id();
+  static const int kGameAccountIdFieldNumber = 6;
+  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.challenge.v1.ChallengeUserRequest)
+ private:
+  inline void set_has_context();
+  inline void clear_has_context();
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_deadline();
+  inline void clear_has_deadline();
+  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_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge > challenges_;
+  ::google::protobuf::uint32 context_;
+  ::google::protobuf::uint32 id_;
+  ::google::protobuf::uint64 deadline_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attributes_;
+  ::bgs::protocol::EntityId* game_account_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto();
+  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ChallengeUserRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ChallengeResultRequest : public ::google::protobuf::Message {
+ public:
+  ChallengeResultRequest();
+  virtual ~ChallengeResultRequest();
+
+  ChallengeResultRequest(const ChallengeResultRequest& from);
+
+  inline ChallengeResultRequest& operator=(const ChallengeResultRequest& 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 ChallengeResultRequest& default_instance();
+
+  void Swap(ChallengeResultRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ChallengeResultRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ChallengeResultRequest& from);
+  void MergeFrom(const ChallengeResultRequest& 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 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // optional fixed32 type = 2;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 2;
+  inline ::google::protobuf::uint32 type() const;
+  inline void set_type(::google::protobuf::uint32 value);
+
+  // optional uint32 error_id = 3;
+  inline bool has_error_id() const;
+  inline void clear_error_id();
+  static const int kErrorIdFieldNumber = 3;
+  inline ::google::protobuf::uint32 error_id() const;
+  inline void set_error_id(::google::protobuf::uint32 value);
+
+  // optional bytes answer = 4;
+  inline bool has_answer() const;
+  inline void clear_answer();
+  static const int kAnswerFieldNumber = 4;
+  inline const ::std::string& answer() const;
+  inline void set_answer(const ::std::string& value);
+  inline void set_answer(const char* value);
+  inline void set_answer(const void* value, size_t size);
+  inline ::std::string* mutable_answer();
+  inline ::std::string* release_answer();
+  inline void set_allocated_answer(::std::string* answer);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeResultRequest)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_error_id();
+  inline void clear_has_error_id();
+  inline void set_has_answer();
+  inline void clear_has_answer();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 id_;
+  ::google::protobuf::uint32 type_;
+  ::std::string* answer_;
+  ::google::protobuf::uint32 error_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto();
+  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ChallengeResultRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ChallengeExternalRequest : public ::google::protobuf::Message {
+ public:
+  ChallengeExternalRequest();
+  virtual ~ChallengeExternalRequest();
+
+  ChallengeExternalRequest(const ChallengeExternalRequest& from);
+
+  inline ChallengeExternalRequest& operator=(const ChallengeExternalRequest& 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 ChallengeExternalRequest& default_instance();
+
+  void Swap(ChallengeExternalRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ChallengeExternalRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ChallengeExternalRequest& from);
+  void MergeFrom(const ChallengeExternalRequest& 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 request_token = 1;
+  inline bool has_request_token() const;
+  inline void clear_request_token();
+  static const int kRequestTokenFieldNumber = 1;
+  inline const ::std::string& request_token() const;
+  inline void set_request_token(const ::std::string& value);
+  inline void set_request_token(const char* value);
+  inline void set_request_token(const char* value, size_t size);
+  inline ::std::string* mutable_request_token();
+  inline ::std::string* release_request_token();
+  inline void set_allocated_request_token(::std::string* request_token);
+
+  // optional string payload_type = 2;
+  inline bool has_payload_type() const;
+  inline void clear_payload_type();
+  static const int kPayloadTypeFieldNumber = 2;
+  inline const ::std::string& payload_type() const;
+  inline void set_payload_type(const ::std::string& value);
+  inline void set_payload_type(const char* value);
+  inline void set_payload_type(const char* value, size_t size);
+  inline ::std::string* mutable_payload_type();
+  inline ::std::string* release_payload_type();
+  inline void set_allocated_payload_type(::std::string* payload_type);
+
+  // optional bytes payload = 3;
+  inline bool has_payload() const;
+  inline void clear_payload();
+  static const int kPayloadFieldNumber = 3;
+  inline const ::std::string& payload() const;
+  inline void set_payload(const ::std::string& value);
+  inline void set_payload(const char* value);
+  inline void set_payload(const void* value, size_t size);
+  inline ::std::string* mutable_payload();
+  inline ::std::string* release_payload();
+  inline void set_allocated_payload(::std::string* payload);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeExternalRequest)
+ private:
+  inline void set_has_request_token();
+  inline void clear_has_request_token();
+  inline void set_has_payload_type();
+  inline void clear_has_payload_type();
+  inline void set_has_payload();
+  inline void clear_has_payload();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* request_token_;
+  ::std::string* payload_type_;
+  ::std::string* payload_;
+  friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto();
+  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ChallengeExternalRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ChallengeExternalResult : public ::google::protobuf::Message {
+ public:
+  ChallengeExternalResult();
+  virtual ~ChallengeExternalResult();
+
+  ChallengeExternalResult(const ChallengeExternalResult& from);
+
+  inline ChallengeExternalResult& operator=(const ChallengeExternalResult& 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 ChallengeExternalResult& default_instance();
+
+  void Swap(ChallengeExternalResult* other);
+
+  // implements Message ----------------------------------------------
+
+  ChallengeExternalResult* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ChallengeExternalResult& from);
+  void MergeFrom(const ChallengeExternalResult& 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 request_token = 1;
+  inline bool has_request_token() const;
+  inline void clear_request_token();
+  static const int kRequestTokenFieldNumber = 1;
+  inline const ::std::string& request_token() const;
+  inline void set_request_token(const ::std::string& value);
+  inline void set_request_token(const char* value);
+  inline void set_request_token(const char* value, size_t size);
+  inline ::std::string* mutable_request_token();
+  inline ::std::string* release_request_token();
+  inline void set_allocated_request_token(::std::string* request_token);
+
+  // optional bool passed = 2 [default = true];
+  inline bool has_passed() const;
+  inline void clear_passed();
+  static const int kPassedFieldNumber = 2;
+  inline bool passed() const;
+  inline void set_passed(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.challenge.v1.ChallengeExternalResult)
+ private:
+  inline void set_has_request_token();
+  inline void clear_has_request_token();
+  inline void set_has_passed();
+  inline void clear_has_passed();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* request_token_;
+  bool passed_;
+  friend void TC_SHARED_API protobuf_AddDesc_challenge_5fservice_2eproto();
+  friend void protobuf_AssignDesc_challenge_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_challenge_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ChallengeExternalResult* default_instance_;
+};
+// ===================================================================
+
+class TC_SHARED_API ChallengeService : public ServiceBase
+{
+ public:
+
+  template<typename HashSelector>
+  explicit ChallengeService(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  typedef std::integral_constant<uint32, 0xDBBF6F19u> OriginalHash;
+  typedef std::integral_constant<uint32, 0x71BB6833u> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void ChallengePicked(::bgs::protocol::challenge::v1::ChallengePickedRequest const* request, std::function<void(::bgs::protocol::challenge::v1::ChallengePickedResponse const*)> responseCallback);
+  void ChallengeAnswered(::bgs::protocol::challenge::v1::ChallengeAnsweredRequest const* request, std::function<void(::bgs::protocol::challenge::v1::ChallengeAnsweredResponse const*)> responseCallback);
+  void ChallengeCancelled(::bgs::protocol::challenge::v1::ChallengeCancelledRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void SendChallengeToUser(::bgs::protocol::challenge::v1::SendChallengeToUserRequest const* request, std::function<void(::bgs::protocol::challenge::v1::SendChallengeToUserResponse const*)> responseCallback);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleChallengePicked(::bgs::protocol::challenge::v1::ChallengePickedRequest const* request, ::bgs::protocol::challenge::v1::ChallengePickedResponse* response);
+  virtual uint32 HandleChallengeAnswered(::bgs::protocol::challenge::v1::ChallengeAnsweredRequest const* request, ::bgs::protocol::challenge::v1::ChallengeAnsweredResponse* response);
+  virtual uint32 HandleChallengeCancelled(::bgs::protocol::challenge::v1::ChallengeCancelledRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleSendChallengeToUser(::bgs::protocol::challenge::v1::SendChallengeToUserRequest const* request, ::bgs::protocol::challenge::v1::SendChallengeToUserResponse* response);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ChallengeService);
+};
+
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ChallengeListener : public ServiceBase
+{
+ public:
+
+  template<typename HashSelector>
+  explicit ChallengeListener(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  typedef std::integral_constant<uint32, 0xBBDA171Fu> OriginalHash;
+  typedef std::integral_constant<uint32, 0xC6D90AB8u> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void OnChallengeUser(::bgs::protocol::challenge::v1::ChallengeUserRequest const* request);
+  void OnChallengeResult(::bgs::protocol::challenge::v1::ChallengeResultRequest const* request);
+  void OnExternalChallenge(::bgs::protocol::challenge::v1::ChallengeExternalRequest const* request);
+  void OnExternalChallengeResult(::bgs::protocol::challenge::v1::ChallengeExternalResult const* request);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleOnChallengeUser(::bgs::protocol::challenge::v1::ChallengeUserRequest const* request);
+  virtual uint32 HandleOnChallengeResult(::bgs::protocol::challenge::v1::ChallengeResultRequest const* request);
+  virtual uint32 HandleOnExternalChallenge(::bgs::protocol::challenge::v1::ChallengeExternalRequest const* request);
+  virtual uint32 HandleOnExternalChallengeResult(::bgs::protocol::challenge::v1::ChallengeExternalResult const* request);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ChallengeListener);
+};
+
+// ===================================================================
+
+
+// ===================================================================
+
+// Challenge
+
+// required fixed32 type = 1;
+inline bool Challenge::has_type() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Challenge::set_has_type() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Challenge::clear_has_type() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Challenge::clear_type() {
+  type_ = 0u;
+  clear_has_type();
+}
+inline ::google::protobuf::uint32 Challenge::type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.Challenge.type)
+  return type_;
+}
+inline void Challenge::set_type(::google::protobuf::uint32 value) {
+  set_has_type();
+  type_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.Challenge.type)
+}
+
+// optional string info = 2;
+inline bool Challenge::has_info() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Challenge::set_has_info() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Challenge::clear_has_info() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Challenge::clear_info() {
+  if (info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    info_->clear();
+  }
+  clear_has_info();
+}
+inline const ::std::string& Challenge::info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.Challenge.info)
+  return *info_;
+}
+inline void Challenge::set_info(const ::std::string& value) {
+  set_has_info();
+  if (info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    info_ = new ::std::string;
+  }
+  info_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.Challenge.info)
+}
+inline void Challenge::set_info(const char* value) {
+  set_has_info();
+  if (info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    info_ = new ::std::string;
+  }
+  info_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.Challenge.info)
+}
+inline void Challenge::set_info(const char* value, size_t size) {
+  set_has_info();
+  if (info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    info_ = new ::std::string;
+  }
+  info_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.Challenge.info)
+}
+inline ::std::string* Challenge::mutable_info() {
+  set_has_info();
+  if (info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    info_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.Challenge.info)
+  return info_;
+}
+inline ::std::string* Challenge::release_info() {
+  clear_has_info();
+  if (info_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = info_;
+    info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Challenge::set_allocated_info(::std::string* info) {
+  if (info_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete info_;
+  }
+  if (info) {
+    set_has_info();
+    info_ = info;
+  } else {
+    clear_has_info();
+    info_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.Challenge.info)
+}
+
+// optional string answer = 3;
+inline bool Challenge::has_answer() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Challenge::set_has_answer() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Challenge::clear_has_answer() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Challenge::clear_answer() {
+  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    answer_->clear();
+  }
+  clear_has_answer();
+}
+inline const ::std::string& Challenge::answer() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.Challenge.answer)
+  return *answer_;
+}
+inline void Challenge::set_answer(const ::std::string& value) {
+  set_has_answer();
+  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    answer_ = new ::std::string;
+  }
+  answer_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.Challenge.answer)
+}
+inline void Challenge::set_answer(const char* value) {
+  set_has_answer();
+  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    answer_ = new ::std::string;
+  }
+  answer_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.Challenge.answer)
+}
+inline void Challenge::set_answer(const char* value, size_t size) {
+  set_has_answer();
+  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    answer_ = new ::std::string;
+  }
+  answer_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.Challenge.answer)
+}
+inline ::std::string* Challenge::mutable_answer() {
+  set_has_answer();
+  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    answer_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.Challenge.answer)
+  return answer_;
+}
+inline ::std::string* Challenge::release_answer() {
+  clear_has_answer();
+  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = answer_;
+    answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Challenge::set_allocated_answer(::std::string* answer) {
+  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete answer_;
+  }
+  if (answer) {
+    set_has_answer();
+    answer_ = answer;
+  } else {
+    clear_has_answer();
+    answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.Challenge.answer)
+}
+
+// optional uint32 retries = 4;
+inline bool Challenge::has_retries() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Challenge::set_has_retries() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Challenge::clear_has_retries() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Challenge::clear_retries() {
+  retries_ = 0u;
+  clear_has_retries();
+}
+inline ::google::protobuf::uint32 Challenge::retries() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.Challenge.retries)
+  return retries_;
+}
+inline void Challenge::set_retries(::google::protobuf::uint32 value) {
+  set_has_retries();
+  retries_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.Challenge.retries)
+}
+
+// -------------------------------------------------------------------
+
+// ChallengePickedRequest
+
+// required fixed32 challenge = 1;
+inline bool ChallengePickedRequest::has_challenge() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ChallengePickedRequest::set_has_challenge() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ChallengePickedRequest::clear_has_challenge() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ChallengePickedRequest::clear_challenge() {
+  challenge_ = 0u;
+  clear_has_challenge();
+}
+inline ::google::protobuf::uint32 ChallengePickedRequest::challenge() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengePickedRequest.challenge)
+  return challenge_;
+}
+inline void ChallengePickedRequest::set_challenge(::google::protobuf::uint32 value) {
+  set_has_challenge();
+  challenge_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengePickedRequest.challenge)
+}
+
+// optional uint32 id = 2;
+inline bool ChallengePickedRequest::has_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ChallengePickedRequest::set_has_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ChallengePickedRequest::clear_has_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ChallengePickedRequest::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 ChallengePickedRequest::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengePickedRequest.id)
+  return id_;
+}
+inline void ChallengePickedRequest::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengePickedRequest.id)
+}
+
+// optional bool new_challenge_protocol = 3 [default = false];
+inline bool ChallengePickedRequest::has_new_challenge_protocol() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ChallengePickedRequest::set_has_new_challenge_protocol() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ChallengePickedRequest::clear_has_new_challenge_protocol() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ChallengePickedRequest::clear_new_challenge_protocol() {
+  new_challenge_protocol_ = false;
+  clear_has_new_challenge_protocol();
+}
+inline bool ChallengePickedRequest::new_challenge_protocol() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengePickedRequest.new_challenge_protocol)
+  return new_challenge_protocol_;
+}
+inline void ChallengePickedRequest::set_new_challenge_protocol(bool value) {
+  set_has_new_challenge_protocol();
+  new_challenge_protocol_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengePickedRequest.new_challenge_protocol)
+}
+
+// -------------------------------------------------------------------
+
+// ChallengePickedResponse
+
+// optional bytes data = 1;
+inline bool ChallengePickedResponse::has_data() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ChallengePickedResponse::set_has_data() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ChallengePickedResponse::clear_has_data() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ChallengePickedResponse::clear_data() {
+  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    data_->clear();
+  }
+  clear_has_data();
+}
+inline const ::std::string& ChallengePickedResponse::data() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengePickedResponse.data)
+  return *data_;
+}
+inline void ChallengePickedResponse::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.challenge.v1.ChallengePickedResponse.data)
+}
+inline void ChallengePickedResponse::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.challenge.v1.ChallengePickedResponse.data)
+}
+inline void ChallengePickedResponse::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.challenge.v1.ChallengePickedResponse.data)
+}
+inline ::std::string* ChallengePickedResponse::mutable_data() {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    data_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengePickedResponse.data)
+  return data_;
+}
+inline ::std::string* ChallengePickedResponse::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 ChallengePickedResponse::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.challenge.v1.ChallengePickedResponse.data)
+}
+
+// -------------------------------------------------------------------
+
+// ChallengeAnsweredRequest
+
+// required string answer = 1;
+inline bool ChallengeAnsweredRequest::has_answer() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ChallengeAnsweredRequest::set_has_answer() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ChallengeAnsweredRequest::clear_has_answer() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ChallengeAnsweredRequest::clear_answer() {
+  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    answer_->clear();
+  }
+  clear_has_answer();
+}
+inline const ::std::string& ChallengeAnsweredRequest::answer() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer)
+  return *answer_;
+}
+inline void ChallengeAnsweredRequest::set_answer(const ::std::string& value) {
+  set_has_answer();
+  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    answer_ = new ::std::string;
+  }
+  answer_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer)
+}
+inline void ChallengeAnsweredRequest::set_answer(const char* value) {
+  set_has_answer();
+  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    answer_ = new ::std::string;
+  }
+  answer_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer)
+}
+inline void ChallengeAnsweredRequest::set_answer(const char* value, size_t size) {
+  set_has_answer();
+  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    answer_ = new ::std::string;
+  }
+  answer_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer)
+}
+inline ::std::string* ChallengeAnsweredRequest::mutable_answer() {
+  set_has_answer();
+  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    answer_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer)
+  return answer_;
+}
+inline ::std::string* ChallengeAnsweredRequest::release_answer() {
+  clear_has_answer();
+  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = answer_;
+    answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ChallengeAnsweredRequest::set_allocated_answer(::std::string* answer) {
+  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete answer_;
+  }
+  if (answer) {
+    set_has_answer();
+    answer_ = answer;
+  } else {
+    clear_has_answer();
+    answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.answer)
+}
+
+// optional bytes data = 2;
+inline bool ChallengeAnsweredRequest::has_data() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ChallengeAnsweredRequest::set_has_data() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ChallengeAnsweredRequest::clear_has_data() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ChallengeAnsweredRequest::clear_data() {
+  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    data_->clear();
+  }
+  clear_has_data();
+}
+inline const ::std::string& ChallengeAnsweredRequest::data() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.data)
+  return *data_;
+}
+inline void ChallengeAnsweredRequest::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.challenge.v1.ChallengeAnsweredRequest.data)
+}
+inline void ChallengeAnsweredRequest::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.challenge.v1.ChallengeAnsweredRequest.data)
+}
+inline void ChallengeAnsweredRequest::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.challenge.v1.ChallengeAnsweredRequest.data)
+}
+inline ::std::string* ChallengeAnsweredRequest::mutable_data() {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    data_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.data)
+  return data_;
+}
+inline ::std::string* ChallengeAnsweredRequest::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 ChallengeAnsweredRequest::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.challenge.v1.ChallengeAnsweredRequest.data)
+}
+
+// optional uint32 id = 3;
+inline bool ChallengeAnsweredRequest::has_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ChallengeAnsweredRequest::set_has_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ChallengeAnsweredRequest::clear_has_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ChallengeAnsweredRequest::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 ChallengeAnsweredRequest::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.id)
+  return id_;
+}
+inline void ChallengeAnsweredRequest::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeAnsweredRequest.id)
+}
+
+// -------------------------------------------------------------------
+
+// ChallengeAnsweredResponse
+
+// optional bytes data = 1;
+inline bool ChallengeAnsweredResponse::has_data() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ChallengeAnsweredResponse::set_has_data() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ChallengeAnsweredResponse::clear_has_data() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ChallengeAnsweredResponse::clear_data() {
+  if (data_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    data_->clear();
+  }
+  clear_has_data();
+}
+inline const ::std::string& ChallengeAnsweredResponse::data() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.data)
+  return *data_;
+}
+inline void ChallengeAnsweredResponse::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.challenge.v1.ChallengeAnsweredResponse.data)
+}
+inline void ChallengeAnsweredResponse::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.challenge.v1.ChallengeAnsweredResponse.data)
+}
+inline void ChallengeAnsweredResponse::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.challenge.v1.ChallengeAnsweredResponse.data)
+}
+inline ::std::string* ChallengeAnsweredResponse::mutable_data() {
+  set_has_data();
+  if (data_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    data_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.data)
+  return data_;
+}
+inline ::std::string* ChallengeAnsweredResponse::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 ChallengeAnsweredResponse::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.challenge.v1.ChallengeAnsweredResponse.data)
+}
+
+// optional bool do_retry = 2;
+inline bool ChallengeAnsweredResponse::has_do_retry() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ChallengeAnsweredResponse::set_has_do_retry() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ChallengeAnsweredResponse::clear_has_do_retry() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ChallengeAnsweredResponse::clear_do_retry() {
+  do_retry_ = false;
+  clear_has_do_retry();
+}
+inline bool ChallengeAnsweredResponse::do_retry() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.do_retry)
+  return do_retry_;
+}
+inline void ChallengeAnsweredResponse::set_do_retry(bool value) {
+  set_has_do_retry();
+  do_retry_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.do_retry)
+}
+
+// optional bool record_not_found = 3;
+inline bool ChallengeAnsweredResponse::has_record_not_found() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ChallengeAnsweredResponse::set_has_record_not_found() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ChallengeAnsweredResponse::clear_has_record_not_found() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ChallengeAnsweredResponse::clear_record_not_found() {
+  record_not_found_ = false;
+  clear_has_record_not_found();
+}
+inline bool ChallengeAnsweredResponse::record_not_found() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.record_not_found)
+  return record_not_found_;
+}
+inline void ChallengeAnsweredResponse::set_record_not_found(bool value) {
+  set_has_record_not_found();
+  record_not_found_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeAnsweredResponse.record_not_found)
+}
+
+// -------------------------------------------------------------------
+
+// ChallengeCancelledRequest
+
+// optional uint32 id = 1;
+inline bool ChallengeCancelledRequest::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ChallengeCancelledRequest::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ChallengeCancelledRequest::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ChallengeCancelledRequest::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 ChallengeCancelledRequest::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeCancelledRequest.id)
+  return id_;
+}
+inline void ChallengeCancelledRequest::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeCancelledRequest.id)
+}
+
+// -------------------------------------------------------------------
+
+// SendChallengeToUserRequest
+
+// optional .bgs.protocol.ProcessId peer_id = 1;
+inline bool SendChallengeToUserRequest::has_peer_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SendChallengeToUserRequest::set_has_peer_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SendChallengeToUserRequest::clear_has_peer_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SendChallengeToUserRequest::clear_peer_id() {
+  if (peer_id_ != NULL) peer_id_->::bgs::protocol::ProcessId::Clear();
+  clear_has_peer_id();
+}
+inline const ::bgs::protocol::ProcessId& SendChallengeToUserRequest::peer_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.peer_id)
+  return peer_id_ != NULL ? *peer_id_ : *default_instance_->peer_id_;
+}
+inline ::bgs::protocol::ProcessId* SendChallengeToUserRequest::mutable_peer_id() {
+  set_has_peer_id();
+  if (peer_id_ == NULL) peer_id_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.peer_id)
+  return peer_id_;
+}
+inline ::bgs::protocol::ProcessId* SendChallengeToUserRequest::release_peer_id() {
+  clear_has_peer_id();
+  ::bgs::protocol::ProcessId* temp = peer_id_;
+  peer_id_ = NULL;
+  return temp;
+}
+inline void SendChallengeToUserRequest::set_allocated_peer_id(::bgs::protocol::ProcessId* peer_id) {
+  delete peer_id_;
+  peer_id_ = peer_id;
+  if (peer_id) {
+    set_has_peer_id();
+  } else {
+    clear_has_peer_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.SendChallengeToUserRequest.peer_id)
+}
+
+// optional .bgs.protocol.EntityId game_account_id = 2;
+inline bool SendChallengeToUserRequest::has_game_account_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SendChallengeToUserRequest::set_has_game_account_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SendChallengeToUserRequest::clear_has_game_account_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SendChallengeToUserRequest::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& SendChallengeToUserRequest::game_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.game_account_id)
+  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
+}
+inline ::bgs::protocol::EntityId* SendChallengeToUserRequest::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.challenge.v1.SendChallengeToUserRequest.game_account_id)
+  return game_account_id_;
+}
+inline ::bgs::protocol::EntityId* SendChallengeToUserRequest::release_game_account_id() {
+  clear_has_game_account_id();
+  ::bgs::protocol::EntityId* temp = game_account_id_;
+  game_account_id_ = NULL;
+  return temp;
+}
+inline void SendChallengeToUserRequest::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.challenge.v1.SendChallengeToUserRequest.game_account_id)
+}
+
+// repeated .bgs.protocol.challenge.v1.Challenge challenges = 3;
+inline int SendChallengeToUserRequest::challenges_size() const {
+  return challenges_.size();
+}
+inline void SendChallengeToUserRequest::clear_challenges() {
+  challenges_.Clear();
+}
+inline const ::bgs::protocol::challenge::v1::Challenge& SendChallengeToUserRequest::challenges(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.challenges)
+  return challenges_.Get(index);
+}
+inline ::bgs::protocol::challenge::v1::Challenge* SendChallengeToUserRequest::mutable_challenges(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.challenges)
+  return challenges_.Mutable(index);
+}
+inline ::bgs::protocol::challenge::v1::Challenge* SendChallengeToUserRequest::add_challenges() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.challenge.v1.SendChallengeToUserRequest.challenges)
+  return challenges_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >&
+SendChallengeToUserRequest::challenges() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.challenge.v1.SendChallengeToUserRequest.challenges)
+  return challenges_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >*
+SendChallengeToUserRequest::mutable_challenges() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.challenge.v1.SendChallengeToUserRequest.challenges)
+  return &challenges_;
+}
+
+// required fixed32 context = 4;
+inline bool SendChallengeToUserRequest::has_context() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void SendChallengeToUserRequest::set_has_context() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void SendChallengeToUserRequest::clear_has_context() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void SendChallengeToUserRequest::clear_context() {
+  context_ = 0u;
+  clear_has_context();
+}
+inline ::google::protobuf::uint32 SendChallengeToUserRequest::context() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.context)
+  return context_;
+}
+inline void SendChallengeToUserRequest::set_context(::google::protobuf::uint32 value) {
+  set_has_context();
+  context_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.SendChallengeToUserRequest.context)
+}
+
+// optional uint64 timeout = 5;
+inline bool SendChallengeToUserRequest::has_timeout() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void SendChallengeToUserRequest::set_has_timeout() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void SendChallengeToUserRequest::clear_has_timeout() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void SendChallengeToUserRequest::clear_timeout() {
+  timeout_ = GOOGLE_ULONGLONG(0);
+  clear_has_timeout();
+}
+inline ::google::protobuf::uint64 SendChallengeToUserRequest::timeout() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.timeout)
+  return timeout_;
+}
+inline void SendChallengeToUserRequest::set_timeout(::google::protobuf::uint64 value) {
+  set_has_timeout();
+  timeout_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.SendChallengeToUserRequest.timeout)
+}
+
+// repeated .bgs.protocol.Attribute attributes = 6;
+inline int SendChallengeToUserRequest::attributes_size() const {
+  return attributes_.size();
+}
+inline void SendChallengeToUserRequest::clear_attributes() {
+  attributes_.Clear();
+}
+inline const ::bgs::protocol::Attribute& SendChallengeToUserRequest::attributes(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.attributes)
+  return attributes_.Get(index);
+}
+inline ::bgs::protocol::Attribute* SendChallengeToUserRequest::mutable_attributes(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.attributes)
+  return attributes_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* SendChallengeToUserRequest::add_attributes() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.challenge.v1.SendChallengeToUserRequest.attributes)
+  return attributes_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+SendChallengeToUserRequest::attributes() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.challenge.v1.SendChallengeToUserRequest.attributes)
+  return attributes_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+SendChallengeToUserRequest::mutable_attributes() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.challenge.v1.SendChallengeToUserRequest.attributes)
+  return &attributes_;
+}
+
+// optional .bgs.protocol.ProcessId host = 7;
+inline bool SendChallengeToUserRequest::has_host() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void SendChallengeToUserRequest::set_has_host() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void SendChallengeToUserRequest::clear_has_host() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void SendChallengeToUserRequest::clear_host() {
+  if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+  clear_has_host();
+}
+inline const ::bgs::protocol::ProcessId& SendChallengeToUserRequest::host() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.host)
+  return host_ != NULL ? *host_ : *default_instance_->host_;
+}
+inline ::bgs::protocol::ProcessId* SendChallengeToUserRequest::mutable_host() {
+  set_has_host();
+  if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.host)
+  return host_;
+}
+inline ::bgs::protocol::ProcessId* SendChallengeToUserRequest::release_host() {
+  clear_has_host();
+  ::bgs::protocol::ProcessId* temp = host_;
+  host_ = NULL;
+  return temp;
+}
+inline void SendChallengeToUserRequest::set_allocated_host(::bgs::protocol::ProcessId* host) {
+  delete host_;
+  host_ = host;
+  if (host) {
+    set_has_host();
+  } else {
+    clear_has_host();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.SendChallengeToUserRequest.host)
+}
+
+// optional .bgs.protocol.EntityId account_id = 8;
+inline bool SendChallengeToUserRequest::has_account_id() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void SendChallengeToUserRequest::set_has_account_id() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void SendChallengeToUserRequest::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void SendChallengeToUserRequest::clear_account_id() {
+  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_account_id();
+}
+inline const ::bgs::protocol::EntityId& SendChallengeToUserRequest::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserRequest.account_id)
+  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
+}
+inline ::bgs::protocol::EntityId* SendChallengeToUserRequest::mutable_account_id() {
+  set_has_account_id();
+  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.SendChallengeToUserRequest.account_id)
+  return account_id_;
+}
+inline ::bgs::protocol::EntityId* SendChallengeToUserRequest::release_account_id() {
+  clear_has_account_id();
+  ::bgs::protocol::EntityId* temp = account_id_;
+  account_id_ = NULL;
+  return temp;
+}
+inline void SendChallengeToUserRequest::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.challenge.v1.SendChallengeToUserRequest.account_id)
+}
+
+// -------------------------------------------------------------------
+
+// SendChallengeToUserResponse
+
+// optional uint32 id = 1;
+inline bool SendChallengeToUserResponse::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SendChallengeToUserResponse::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SendChallengeToUserResponse::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SendChallengeToUserResponse::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 SendChallengeToUserResponse::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.SendChallengeToUserResponse.id)
+  return id_;
+}
+inline void SendChallengeToUserResponse::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.SendChallengeToUserResponse.id)
+}
+
+// -------------------------------------------------------------------
+
+// ChallengeUserRequest
+
+// repeated .bgs.protocol.challenge.v1.Challenge challenges = 1;
+inline int ChallengeUserRequest::challenges_size() const {
+  return challenges_.size();
+}
+inline void ChallengeUserRequest::clear_challenges() {
+  challenges_.Clear();
+}
+inline const ::bgs::protocol::challenge::v1::Challenge& ChallengeUserRequest::challenges(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.challenges)
+  return challenges_.Get(index);
+}
+inline ::bgs::protocol::challenge::v1::Challenge* ChallengeUserRequest::mutable_challenges(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeUserRequest.challenges)
+  return challenges_.Mutable(index);
+}
+inline ::bgs::protocol::challenge::v1::Challenge* ChallengeUserRequest::add_challenges() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.challenge.v1.ChallengeUserRequest.challenges)
+  return challenges_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >&
+ChallengeUserRequest::challenges() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.challenge.v1.ChallengeUserRequest.challenges)
+  return challenges_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::challenge::v1::Challenge >*
+ChallengeUserRequest::mutable_challenges() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.challenge.v1.ChallengeUserRequest.challenges)
+  return &challenges_;
+}
+
+// required fixed32 context = 2;
+inline bool ChallengeUserRequest::has_context() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ChallengeUserRequest::set_has_context() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ChallengeUserRequest::clear_has_context() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ChallengeUserRequest::clear_context() {
+  context_ = 0u;
+  clear_has_context();
+}
+inline ::google::protobuf::uint32 ChallengeUserRequest::context() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.context)
+  return context_;
+}
+inline void ChallengeUserRequest::set_context(::google::protobuf::uint32 value) {
+  set_has_context();
+  context_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeUserRequest.context)
+}
+
+// optional uint32 id = 3;
+inline bool ChallengeUserRequest::has_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ChallengeUserRequest::set_has_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ChallengeUserRequest::clear_has_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ChallengeUserRequest::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 ChallengeUserRequest::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.id)
+  return id_;
+}
+inline void ChallengeUserRequest::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeUserRequest.id)
+}
+
+// optional uint64 deadline = 4;
+inline bool ChallengeUserRequest::has_deadline() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ChallengeUserRequest::set_has_deadline() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ChallengeUserRequest::clear_has_deadline() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ChallengeUserRequest::clear_deadline() {
+  deadline_ = GOOGLE_ULONGLONG(0);
+  clear_has_deadline();
+}
+inline ::google::protobuf::uint64 ChallengeUserRequest::deadline() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.deadline)
+  return deadline_;
+}
+inline void ChallengeUserRequest::set_deadline(::google::protobuf::uint64 value) {
+  set_has_deadline();
+  deadline_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeUserRequest.deadline)
+}
+
+// repeated .bgs.protocol.Attribute attributes = 5;
+inline int ChallengeUserRequest::attributes_size() const {
+  return attributes_.size();
+}
+inline void ChallengeUserRequest::clear_attributes() {
+  attributes_.Clear();
+}
+inline const ::bgs::protocol::Attribute& ChallengeUserRequest::attributes(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.attributes)
+  return attributes_.Get(index);
+}
+inline ::bgs::protocol::Attribute* ChallengeUserRequest::mutable_attributes(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeUserRequest.attributes)
+  return attributes_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* ChallengeUserRequest::add_attributes() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.challenge.v1.ChallengeUserRequest.attributes)
+  return attributes_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+ChallengeUserRequest::attributes() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.challenge.v1.ChallengeUserRequest.attributes)
+  return attributes_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+ChallengeUserRequest::mutable_attributes() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.challenge.v1.ChallengeUserRequest.attributes)
+  return &attributes_;
+}
+
+// optional .bgs.protocol.EntityId game_account_id = 6;
+inline bool ChallengeUserRequest::has_game_account_id() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ChallengeUserRequest::set_has_game_account_id() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ChallengeUserRequest::clear_has_game_account_id() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ChallengeUserRequest::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& ChallengeUserRequest::game_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeUserRequest.game_account_id)
+  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
+}
+inline ::bgs::protocol::EntityId* ChallengeUserRequest::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.challenge.v1.ChallengeUserRequest.game_account_id)
+  return game_account_id_;
+}
+inline ::bgs::protocol::EntityId* ChallengeUserRequest::release_game_account_id() {
+  clear_has_game_account_id();
+  ::bgs::protocol::EntityId* temp = game_account_id_;
+  game_account_id_ = NULL;
+  return temp;
+}
+inline void ChallengeUserRequest::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.challenge.v1.ChallengeUserRequest.game_account_id)
+}
+
+// -------------------------------------------------------------------
+
+// ChallengeResultRequest
+
+// optional uint32 id = 1;
+inline bool ChallengeResultRequest::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ChallengeResultRequest::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ChallengeResultRequest::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ChallengeResultRequest::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 ChallengeResultRequest::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeResultRequest.id)
+  return id_;
+}
+inline void ChallengeResultRequest::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeResultRequest.id)
+}
+
+// optional fixed32 type = 2;
+inline bool ChallengeResultRequest::has_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ChallengeResultRequest::set_has_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ChallengeResultRequest::clear_has_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ChallengeResultRequest::clear_type() {
+  type_ = 0u;
+  clear_has_type();
+}
+inline ::google::protobuf::uint32 ChallengeResultRequest::type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeResultRequest.type)
+  return type_;
+}
+inline void ChallengeResultRequest::set_type(::google::protobuf::uint32 value) {
+  set_has_type();
+  type_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeResultRequest.type)
+}
+
+// optional uint32 error_id = 3;
+inline bool ChallengeResultRequest::has_error_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ChallengeResultRequest::set_has_error_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ChallengeResultRequest::clear_has_error_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ChallengeResultRequest::clear_error_id() {
+  error_id_ = 0u;
+  clear_has_error_id();
+}
+inline ::google::protobuf::uint32 ChallengeResultRequest::error_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeResultRequest.error_id)
+  return error_id_;
+}
+inline void ChallengeResultRequest::set_error_id(::google::protobuf::uint32 value) {
+  set_has_error_id();
+  error_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeResultRequest.error_id)
+}
+
+// optional bytes answer = 4;
+inline bool ChallengeResultRequest::has_answer() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ChallengeResultRequest::set_has_answer() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ChallengeResultRequest::clear_has_answer() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ChallengeResultRequest::clear_answer() {
+  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    answer_->clear();
+  }
+  clear_has_answer();
+}
+inline const ::std::string& ChallengeResultRequest::answer() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeResultRequest.answer)
+  return *answer_;
+}
+inline void ChallengeResultRequest::set_answer(const ::std::string& value) {
+  set_has_answer();
+  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    answer_ = new ::std::string;
+  }
+  answer_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeResultRequest.answer)
+}
+inline void ChallengeResultRequest::set_answer(const char* value) {
+  set_has_answer();
+  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    answer_ = new ::std::string;
+  }
+  answer_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeResultRequest.answer)
+}
+inline void ChallengeResultRequest::set_answer(const void* value, size_t size) {
+  set_has_answer();
+  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    answer_ = new ::std::string;
+  }
+  answer_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeResultRequest.answer)
+}
+inline ::std::string* ChallengeResultRequest::mutable_answer() {
+  set_has_answer();
+  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    answer_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeResultRequest.answer)
+  return answer_;
+}
+inline ::std::string* ChallengeResultRequest::release_answer() {
+  clear_has_answer();
+  if (answer_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = answer_;
+    answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ChallengeResultRequest::set_allocated_answer(::std::string* answer) {
+  if (answer_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete answer_;
+  }
+  if (answer) {
+    set_has_answer();
+    answer_ = answer;
+  } else {
+    clear_has_answer();
+    answer_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeResultRequest.answer)
+}
+
+// -------------------------------------------------------------------
+
+// ChallengeExternalRequest
+
+// optional string request_token = 1;
+inline bool ChallengeExternalRequest::has_request_token() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ChallengeExternalRequest::set_has_request_token() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ChallengeExternalRequest::clear_has_request_token() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ChallengeExternalRequest::clear_request_token() {
+  if (request_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    request_token_->clear();
+  }
+  clear_has_request_token();
+}
+inline const ::std::string& ChallengeExternalRequest::request_token() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeExternalRequest.request_token)
+  return *request_token_;
+}
+inline void ChallengeExternalRequest::set_request_token(const ::std::string& value) {
+  set_has_request_token();
+  if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    request_token_ = new ::std::string;
+  }
+  request_token_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeExternalRequest.request_token)
+}
+inline void ChallengeExternalRequest::set_request_token(const char* value) {
+  set_has_request_token();
+  if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    request_token_ = new ::std::string;
+  }
+  request_token_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeExternalRequest.request_token)
+}
+inline void ChallengeExternalRequest::set_request_token(const char* value, size_t size) {
+  set_has_request_token();
+  if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    request_token_ = new ::std::string;
+  }
+  request_token_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeExternalRequest.request_token)
+}
+inline ::std::string* ChallengeExternalRequest::mutable_request_token() {
+  set_has_request_token();
+  if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    request_token_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeExternalRequest.request_token)
+  return request_token_;
+}
+inline ::std::string* ChallengeExternalRequest::release_request_token() {
+  clear_has_request_token();
+  if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = request_token_;
+    request_token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ChallengeExternalRequest::set_allocated_request_token(::std::string* request_token) {
+  if (request_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete request_token_;
+  }
+  if (request_token) {
+    set_has_request_token();
+    request_token_ = request_token;
+  } else {
+    clear_has_request_token();
+    request_token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeExternalRequest.request_token)
+}
+
+// optional string payload_type = 2;
+inline bool ChallengeExternalRequest::has_payload_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ChallengeExternalRequest::set_has_payload_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ChallengeExternalRequest::clear_has_payload_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ChallengeExternalRequest::clear_payload_type() {
+  if (payload_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_type_->clear();
+  }
+  clear_has_payload_type();
+}
+inline const ::std::string& ChallengeExternalRequest::payload_type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload_type)
+  return *payload_type_;
+}
+inline void ChallengeExternalRequest::set_payload_type(const ::std::string& value) {
+  set_has_payload_type();
+  if (payload_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_type_ = new ::std::string;
+  }
+  payload_type_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload_type)
+}
+inline void ChallengeExternalRequest::set_payload_type(const char* value) {
+  set_has_payload_type();
+  if (payload_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_type_ = new ::std::string;
+  }
+  payload_type_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload_type)
+}
+inline void ChallengeExternalRequest::set_payload_type(const char* value, size_t size) {
+  set_has_payload_type();
+  if (payload_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_type_ = new ::std::string;
+  }
+  payload_type_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload_type)
+}
+inline ::std::string* ChallengeExternalRequest::mutable_payload_type() {
+  set_has_payload_type();
+  if (payload_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_type_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload_type)
+  return payload_type_;
+}
+inline ::std::string* ChallengeExternalRequest::release_payload_type() {
+  clear_has_payload_type();
+  if (payload_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = payload_type_;
+    payload_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ChallengeExternalRequest::set_allocated_payload_type(::std::string* payload_type) {
+  if (payload_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete payload_type_;
+  }
+  if (payload_type) {
+    set_has_payload_type();
+    payload_type_ = payload_type;
+  } else {
+    clear_has_payload_type();
+    payload_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload_type)
+}
+
+// optional bytes payload = 3;
+inline bool ChallengeExternalRequest::has_payload() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ChallengeExternalRequest::set_has_payload() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ChallengeExternalRequest::clear_has_payload() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ChallengeExternalRequest::clear_payload() {
+  if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_->clear();
+  }
+  clear_has_payload();
+}
+inline const ::std::string& ChallengeExternalRequest::payload() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload)
+  return *payload_;
+}
+inline void ChallengeExternalRequest::set_payload(const ::std::string& value) {
+  set_has_payload();
+  if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_ = new ::std::string;
+  }
+  payload_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload)
+}
+inline void ChallengeExternalRequest::set_payload(const char* value) {
+  set_has_payload();
+  if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_ = new ::std::string;
+  }
+  payload_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload)
+}
+inline void ChallengeExternalRequest::set_payload(const void* value, size_t size) {
+  set_has_payload();
+  if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_ = new ::std::string;
+  }
+  payload_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload)
+}
+inline ::std::string* ChallengeExternalRequest::mutable_payload() {
+  set_has_payload();
+  if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload)
+  return payload_;
+}
+inline ::std::string* ChallengeExternalRequest::release_payload() {
+  clear_has_payload();
+  if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = payload_;
+    payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ChallengeExternalRequest::set_allocated_payload(::std::string* payload) {
+  if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete payload_;
+  }
+  if (payload) {
+    set_has_payload();
+    payload_ = payload;
+  } else {
+    clear_has_payload();
+    payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeExternalRequest.payload)
+}
+
+// -------------------------------------------------------------------
+
+// ChallengeExternalResult
+
+// optional string request_token = 1;
+inline bool ChallengeExternalResult::has_request_token() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ChallengeExternalResult::set_has_request_token() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ChallengeExternalResult::clear_has_request_token() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ChallengeExternalResult::clear_request_token() {
+  if (request_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    request_token_->clear();
+  }
+  clear_has_request_token();
+}
+inline const ::std::string& ChallengeExternalResult::request_token() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeExternalResult.request_token)
+  return *request_token_;
+}
+inline void ChallengeExternalResult::set_request_token(const ::std::string& value) {
+  set_has_request_token();
+  if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    request_token_ = new ::std::string;
+  }
+  request_token_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeExternalResult.request_token)
+}
+inline void ChallengeExternalResult::set_request_token(const char* value) {
+  set_has_request_token();
+  if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    request_token_ = new ::std::string;
+  }
+  request_token_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.challenge.v1.ChallengeExternalResult.request_token)
+}
+inline void ChallengeExternalResult::set_request_token(const char* value, size_t size) {
+  set_has_request_token();
+  if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    request_token_ = new ::std::string;
+  }
+  request_token_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.challenge.v1.ChallengeExternalResult.request_token)
+}
+inline ::std::string* ChallengeExternalResult::mutable_request_token() {
+  set_has_request_token();
+  if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    request_token_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.challenge.v1.ChallengeExternalResult.request_token)
+  return request_token_;
+}
+inline ::std::string* ChallengeExternalResult::release_request_token() {
+  clear_has_request_token();
+  if (request_token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = request_token_;
+    request_token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ChallengeExternalResult::set_allocated_request_token(::std::string* request_token) {
+  if (request_token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete request_token_;
+  }
+  if (request_token) {
+    set_has_request_token();
+    request_token_ = request_token;
+  } else {
+    clear_has_request_token();
+    request_token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.challenge.v1.ChallengeExternalResult.request_token)
+}
+
+// optional bool passed = 2 [default = true];
+inline bool ChallengeExternalResult::has_passed() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ChallengeExternalResult::set_has_passed() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ChallengeExternalResult::clear_has_passed() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ChallengeExternalResult::clear_passed() {
+  passed_ = true;
+  clear_has_passed();
+}
+inline bool ChallengeExternalResult::passed() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.challenge.v1.ChallengeExternalResult.passed)
+  return passed_;
+}
+inline void ChallengeExternalResult::set_passed(bool value) {
+  set_has_passed();
+  passed_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.challenge.v1.ChallengeExternalResult.passed)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace challenge
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_challenge_5fservice_2eproto__INCLUDED
diff --git a/src/server/proto/Client/channel_service.pb.cc b/src/server/proto/Client/channel_service.pb.cc
new file mode 100644
index 00000000000..3c2b099d938
--- /dev/null
+++ b/src/server/proto/Client/channel_service.pb.cc
@@ -0,0 +1,6487 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: channel_service.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "channel_service.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+#include "BattlenetRpcErrorCodes.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace channel {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* AddMemberRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AddMemberRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RemoveMemberRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RemoveMemberRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UnsubscribeMemberRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UnsubscribeMemberRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SendMessageRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SendMessageRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UpdateChannelStateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UpdateChannelStateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UpdateMemberStateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UpdateMemberStateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* DissolveRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  DissolveRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SetRolesRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SetRolesRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* JoinNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  JoinNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MemberAddedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemberAddedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* LeaveNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  LeaveNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* MemberRemovedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemberRemovedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SendMessageNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SendMessageNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UpdateChannelStateNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UpdateChannelStateNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UpdateMemberStateNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UpdateMemberStateNotification_reflection_ = NULL;
+const ::google::protobuf::ServiceDescriptor* ChannelService_descriptor_ = NULL;
+const ::google::protobuf::ServiceDescriptor* ChannelListener_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_channel_5fservice_2eproto() {
+  protobuf_AddDesc_channel_5fservice_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "channel_service.proto");
+  GOOGLE_CHECK(file != NULL);
+  AddMemberRequest_descriptor_ = file->message_type(0);
+  static const int AddMemberRequest_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddMemberRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddMemberRequest, member_identity_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddMemberRequest, member_state_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddMemberRequest, object_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddMemberRequest, subscribe_),
+  };
+  AddMemberRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AddMemberRequest_descriptor_,
+      AddMemberRequest::default_instance_,
+      AddMemberRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddMemberRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddMemberRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AddMemberRequest));
+  RemoveMemberRequest_descriptor_ = file->message_type(1);
+  static const int RemoveMemberRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberRequest, member_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberRequest, reason_),
+  };
+  RemoveMemberRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RemoveMemberRequest_descriptor_,
+      RemoveMemberRequest::default_instance_,
+      RemoveMemberRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RemoveMemberRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RemoveMemberRequest));
+  UnsubscribeMemberRequest_descriptor_ = file->message_type(2);
+  static const int UnsubscribeMemberRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeMemberRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeMemberRequest, member_id_),
+  };
+  UnsubscribeMemberRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UnsubscribeMemberRequest_descriptor_,
+      UnsubscribeMemberRequest::default_instance_,
+      UnsubscribeMemberRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeMemberRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeMemberRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UnsubscribeMemberRequest));
+  SendMessageRequest_descriptor_ = file->message_type(3);
+  static const int SendMessageRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageRequest, message_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageRequest, required_privileges_),
+  };
+  SendMessageRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SendMessageRequest_descriptor_,
+      SendMessageRequest::default_instance_,
+      SendMessageRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SendMessageRequest));
+  UpdateChannelStateRequest_descriptor_ = file->message_type(4);
+  static const int UpdateChannelStateRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateRequest, state_change_),
+  };
+  UpdateChannelStateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UpdateChannelStateRequest_descriptor_,
+      UpdateChannelStateRequest::default_instance_,
+      UpdateChannelStateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UpdateChannelStateRequest));
+  UpdateMemberStateRequest_descriptor_ = file->message_type(5);
+  static const int UpdateMemberStateRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, state_change_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, removed_role_),
+  };
+  UpdateMemberStateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UpdateMemberStateRequest_descriptor_,
+      UpdateMemberStateRequest::default_instance_,
+      UpdateMemberStateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UpdateMemberStateRequest));
+  DissolveRequest_descriptor_ = file->message_type(6);
+  static const int DissolveRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DissolveRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DissolveRequest, reason_),
+  };
+  DissolveRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      DissolveRequest_descriptor_,
+      DissolveRequest::default_instance_,
+      DissolveRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DissolveRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DissolveRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(DissolveRequest));
+  SetRolesRequest_descriptor_ = file->message_type(7);
+  static const int SetRolesRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetRolesRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetRolesRequest, role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetRolesRequest, member_id_),
+  };
+  SetRolesRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SetRolesRequest_descriptor_,
+      SetRolesRequest::default_instance_,
+      SetRolesRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetRolesRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetRolesRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SetRolesRequest));
+  JoinNotification_descriptor_ = file->message_type(8);
+  static const int JoinNotification_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, self_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, member_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, channel_state_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, channel_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, subscriber_),
+  };
+  JoinNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      JoinNotification_descriptor_,
+      JoinNotification::default_instance_,
+      JoinNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(JoinNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(JoinNotification));
+  MemberAddedNotification_descriptor_ = file->message_type(9);
+  static const int MemberAddedNotification_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, member_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, channel_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, subscriber_),
+  };
+  MemberAddedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemberAddedNotification_descriptor_,
+      MemberAddedNotification::default_instance_,
+      MemberAddedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberAddedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemberAddedNotification));
+  LeaveNotification_descriptor_ = file->message_type(10);
+  static const int LeaveNotification_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, member_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, reason_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, channel_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, subscriber_),
+  };
+  LeaveNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      LeaveNotification_descriptor_,
+      LeaveNotification::default_instance_,
+      LeaveNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LeaveNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(LeaveNotification));
+  MemberRemovedNotification_descriptor_ = file->message_type(11);
+  static const int MemberRemovedNotification_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, member_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, reason_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, channel_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, subscriber_),
+  };
+  MemberRemovedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemberRemovedNotification_descriptor_,
+      MemberRemovedNotification::default_instance_,
+      MemberRemovedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberRemovedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemberRemovedNotification));
+  SendMessageNotification_descriptor_ = file->message_type(12);
+  static const int SendMessageNotification_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, message_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, required_privileges_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, identity_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, channel_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, subscriber_),
+  };
+  SendMessageNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SendMessageNotification_descriptor_,
+      SendMessageNotification::default_instance_,
+      SendMessageNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendMessageNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SendMessageNotification));
+  UpdateChannelStateNotification_descriptor_ = file->message_type(13);
+  static const int UpdateChannelStateNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, state_change_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, channel_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, subscriber_),
+  };
+  UpdateChannelStateNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UpdateChannelStateNotification_descriptor_,
+      UpdateChannelStateNotification::default_instance_,
+      UpdateChannelStateNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateChannelStateNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UpdateChannelStateNotification));
+  UpdateMemberStateNotification_descriptor_ = file->message_type(14);
+  static const int UpdateMemberStateNotification_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, state_change_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, removed_role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, channel_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, subscriber_),
+  };
+  UpdateMemberStateNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UpdateMemberStateNotification_descriptor_,
+      UpdateMemberStateNotification::default_instance_,
+      UpdateMemberStateNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateMemberStateNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UpdateMemberStateNotification));
+  ChannelService_descriptor_ = file->service(0);
+  ChannelListener_descriptor_ = file->service(1);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_channel_5fservice_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AddMemberRequest_descriptor_, &AddMemberRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RemoveMemberRequest_descriptor_, &RemoveMemberRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UnsubscribeMemberRequest_descriptor_, &UnsubscribeMemberRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SendMessageRequest_descriptor_, &SendMessageRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UpdateChannelStateRequest_descriptor_, &UpdateChannelStateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UpdateMemberStateRequest_descriptor_, &UpdateMemberStateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    DissolveRequest_descriptor_, &DissolveRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SetRolesRequest_descriptor_, &SetRolesRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    JoinNotification_descriptor_, &JoinNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemberAddedNotification_descriptor_, &MemberAddedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    LeaveNotification_descriptor_, &LeaveNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemberRemovedNotification_descriptor_, &MemberRemovedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SendMessageNotification_descriptor_, &SendMessageNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UpdateChannelStateNotification_descriptor_, &UpdateChannelStateNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UpdateMemberStateNotification_descriptor_, &UpdateMemberStateNotification::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_channel_5fservice_2eproto() {
+  delete AddMemberRequest::default_instance_;
+  delete AddMemberRequest_reflection_;
+  delete RemoveMemberRequest::default_instance_;
+  delete RemoveMemberRequest_reflection_;
+  delete UnsubscribeMemberRequest::default_instance_;
+  delete UnsubscribeMemberRequest_reflection_;
+  delete SendMessageRequest::default_instance_;
+  delete SendMessageRequest_reflection_;
+  delete UpdateChannelStateRequest::default_instance_;
+  delete UpdateChannelStateRequest_reflection_;
+  delete UpdateMemberStateRequest::default_instance_;
+  delete UpdateMemberStateRequest_reflection_;
+  delete DissolveRequest::default_instance_;
+  delete DissolveRequest_reflection_;
+  delete SetRolesRequest::default_instance_;
+  delete SetRolesRequest_reflection_;
+  delete JoinNotification::default_instance_;
+  delete JoinNotification_reflection_;
+  delete MemberAddedNotification::default_instance_;
+  delete MemberAddedNotification_reflection_;
+  delete LeaveNotification::default_instance_;
+  delete LeaveNotification_reflection_;
+  delete MemberRemovedNotification::default_instance_;
+  delete MemberRemovedNotification_reflection_;
+  delete SendMessageNotification::default_instance_;
+  delete SendMessageNotification_reflection_;
+  delete UpdateChannelStateNotification::default_instance_;
+  delete UpdateChannelStateNotification_reflection_;
+  delete UpdateMemberStateNotification::default_instance_;
+  delete UpdateMemberStateNotification_reflection_;
+}
+
+void protobuf_AddDesc_channel_5fservice_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::account::v1::protobuf_AddDesc_account_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::bgs::protocol::channel::v1::protobuf_AddDesc_channel_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\025channel_service.proto\022\027bgs.protocol.ch"
+    "annel.v1\032\023account_types.proto\032\022entity_ty"
+    "pes.proto\032\023channel_types.proto\032\017rpc_type"
+    "s.proto\"\325\001\n\020AddMemberRequest\022(\n\010agent_id"
+    "\030\001 \001(\0132\026.bgs.protocol.EntityId\022/\n\017member"
+    "_identity\030\002 \002(\0132\026.bgs.protocol.Identity\022"
+    ":\n\014member_state\030\003 \002(\0132$.bgs.protocol.cha"
+    "nnel.v1.MemberState\022\021\n\tobject_id\030\004 \002(\004\022\027"
+    "\n\tsubscribe\030\005 \001(\010:\004true\"z\n\023RemoveMemberR"
+    "equest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.protocol."
+    "EntityId\022)\n\tmember_id\030\002 \002(\0132\026.bgs.protoc"
+    "ol.EntityId\022\016\n\006reason\030\003 \001(\r\"o\n\030Unsubscri"
+    "beMemberRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs."
+    "protocol.EntityId\022)\n\tmember_id\030\002 \002(\0132\026.b"
+    "gs.protocol.EntityId\"\221\001\n\022SendMessageRequ"
+    "est\022(\n\010agent_id\030\001 \001(\0132\026.bgs.protocol.Ent"
+    "ityId\0221\n\007message\030\002 \002(\0132 .bgs.protocol.ch"
+    "annel.v1.Message\022\036\n\023required_privileges\030"
+    "\003 \001(\004:\0010\"\202\001\n\031UpdateChannelStateRequest\022("
+    "\n\010agent_id\030\001 \001(\0132\026.bgs.protocol.EntityId"
+    "\022;\n\014state_change\030\002 \002(\0132%.bgs.protocol.ch"
+    "annel.v1.ChannelState\"\225\001\n\030UpdateMemberSt"
+    "ateRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.proto"
+    "col.EntityId\0225\n\014state_change\030\002 \003(\0132\037.bgs"
+    ".protocol.channel.v1.Member\022\030\n\014removed_r"
+    "ole\030\003 \003(\rB\002\020\001\"K\n\017DissolveRequest\022(\n\010agen"
+    "t_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022\016\n\006re"
+    "ason\030\002 \001(\r\"x\n\017SetRolesRequest\022(\n\010agent_i"
+    "d\030\001 \001(\0132\026.bgs.protocol.EntityId\022\020\n\004role\030"
+    "\002 \003(\rB\002\020\001\022)\n\tmember_id\030\003 \003(\0132\026.bgs.proto"
+    "col.EntityId\"\237\002\n\020JoinNotification\022-\n\004sel"
+    "f\030\001 \001(\0132\037.bgs.protocol.channel.v1.Member"
+    "\022/\n\006member\030\002 \003(\0132\037.bgs.protocol.channel."
+    "v1.Member\022<\n\rchannel_state\030\003 \002(\0132%.bgs.p"
+    "rotocol.channel.v1.ChannelState\0226\n\nchann"
+    "el_id\030\004 \001(\0132\".bgs.protocol.channel.v1.Ch"
+    "annelId\0225\n\nsubscriber\030\005 \001(\0132!.bgs.protoc"
+    "ol.account.v1.Identity\"\271\001\n\027MemberAddedNo"
+    "tification\022/\n\006member\030\001 \002(\0132\037.bgs.protoco"
+    "l.channel.v1.Member\0226\n\nchannel_id\030\002 \001(\0132"
+    "\".bgs.protocol.channel.v1.ChannelId\0225\n\ns"
+    "ubscriber\030\003 \001(\0132!.bgs.protocol.account.v"
+    "1.Identity\"\347\001\n\021LeaveNotification\022(\n\010agen"
+    "t_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022)\n\tme"
+    "mber_id\030\002 \002(\0132\026.bgs.protocol.EntityId\022\016\n"
+    "\006reason\030\003 \001(\r\0226\n\nchannel_id\030\004 \001(\0132\".bgs."
+    "protocol.channel.v1.ChannelId\0225\n\nsubscri"
+    "ber\030\005 \001(\0132!.bgs.protocol.account.v1.Iden"
+    "tity\"\357\001\n\031MemberRemovedNotification\022(\n\010ag"
+    "ent_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022)\n\t"
+    "member_id\030\002 \002(\0132\026.bgs.protocol.EntityId\022"
+    "\016\n\006reason\030\003 \001(\r\0226\n\nchannel_id\030\004 \001(\0132\".bg"
+    "s.protocol.channel.v1.ChannelId\0225\n\nsubsc"
+    "riber\030\005 \001(\0132!.bgs.protocol.account.v1.Id"
+    "entity\"\227\002\n\027SendMessageNotification\022(\n\010ag"
+    "ent_id\030\001 \001(\0132\026.bgs.protocol.EntityId\0221\n\007"
+    "message\030\002 \002(\0132 .bgs.protocol.channel.v1."
+    "Message\022\036\n\023required_privileges\030\003 \001(\004:\0010\022"
+    "\020\n\010identity\030\004 \001(\t\0226\n\nchannel_id\030\005 \001(\0132\"."
+    "bgs.protocol.channel.v1.ChannelId\0225\n\nsub"
+    "scriber\030\006 \001(\0132!.bgs.protocol.account.v1."
+    "Identity\"\366\001\n\036UpdateChannelStateNotificat"
+    "ion\022(\n\010agent_id\030\001 \001(\0132\026.bgs.protocol.Ent"
+    "ityId\022;\n\014state_change\030\002 \002(\0132%.bgs.protoc"
+    "ol.channel.v1.ChannelState\0226\n\nchannel_id"
+    "\030\003 \001(\0132\".bgs.protocol.channel.v1.Channel"
+    "Id\0225\n\nsubscriber\030\004 \001(\0132!.bgs.protocol.ac"
+    "count.v1.Identity\"\211\002\n\035UpdateMemberStateN"
+    "otification\022(\n\010agent_id\030\001 \001(\0132\026.bgs.prot"
+    "ocol.EntityId\0225\n\014state_change\030\002 \003(\0132\037.bg"
+    "s.protocol.channel.v1.Member\022\030\n\014removed_"
+    "role\030\003 \003(\rB\002\020\001\0226\n\nchannel_id\030\004 \001(\0132\".bgs"
+    ".protocol.channel.v1.ChannelId\0225\n\nsubscr"
+    "iber\030\005 \001(\0132!.bgs.protocol.account.v1.Ide"
+    "ntity2\212\006\n\016ChannelService\022R\n\tAddMember\022)."
+    "bgs.protocol.channel.v1.AddMemberRequest"
+    "\032\024.bgs.protocol.NoData\"\004\200\265\030\001\022X\n\014RemoveMe"
+    "mber\022,.bgs.protocol.channel.v1.RemoveMem"
+    "berRequest\032\024.bgs.protocol.NoData\"\004\200\265\030\002\022V"
+    "\n\013SendMessage\022+.bgs.protocol.channel.v1."
+    "SendMessageRequest\032\024.bgs.protocol.NoData"
+    "\"\004\200\265\030\003\022d\n\022UpdateChannelState\0222.bgs.proto"
+    "col.channel.v1.UpdateChannelStateRequest"
+    "\032\024.bgs.protocol.NoData\"\004\200\265\030\004\022b\n\021UpdateMe"
+    "mberState\0221.bgs.protocol.channel.v1.Upda"
+    "teMemberStateRequest\032\024.bgs.protocol.NoDa"
+    "ta\"\004\200\265\030\005\022P\n\010Dissolve\022(.bgs.protocol.chan"
+    "nel.v1.DissolveRequest\032\024.bgs.protocol.No"
+    "Data\"\004\200\265\030\006\022P\n\010SetRoles\022(.bgs.protocol.ch"
+    "annel.v1.SetRolesRequest\032\024.bgs.protocol."
+    "NoData\"\004\200\265\030\007\022b\n\021UnsubscribeMember\0221.bgs."
+    "protocol.channel.v1.UnsubscribeMemberReq"
+    "uest\032\024.bgs.protocol.NoData\"\004\200\265\030\010\032 \312>\035bne"
+    "t.protocol.channel.Channel2\375\005\n\017ChannelLi"
+    "stener\022T\n\006OnJoin\022).bgs.protocol.channel."
+    "v1.JoinNotification\032\031.bgs.protocol.NO_RE"
+    "SPONSE\"\004\200\265\030\001\022b\n\rOnMemberAdded\0220.bgs.prot"
+    "ocol.channel.v1.MemberAddedNotification\032"
+    "\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\002\022V\n\007OnLe"
+    "ave\022*.bgs.protocol.channel.v1.LeaveNotif"
+    "ication\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\003"
+    "\022f\n\017OnMemberRemoved\0222.bgs.protocol.chann"
+    "el.v1.MemberRemovedNotification\032\031.bgs.pr"
+    "otocol.NO_RESPONSE\"\004\200\265\030\004\022b\n\rOnSendMessag"
+    "e\0220.bgs.protocol.channel.v1.SendMessageN"
+    "otification\032\031.bgs.protocol.NO_RESPONSE\"\004"
+    "\200\265\030\005\022p\n\024OnUpdateChannelState\0227.bgs.proto"
+    "col.channel.v1.UpdateChannelStateNotific"
+    "ation\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\006\022n"
+    "\n\023OnUpdateMemberState\0226.bgs.protocol.cha"
+    "nnel.v1.UpdateMemberStateNotification\032\031."
+    "bgs.protocol.NO_RESPONSE\"\004\200\265\030\007\032*\312>\'bnet."
+    "protocol.channel.ChannelSubscriberB\005H\001\200\001"
+    "\000", 4521);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "channel_service.proto", &protobuf_RegisterTypes);
+  AddMemberRequest::default_instance_ = new AddMemberRequest();
+  RemoveMemberRequest::default_instance_ = new RemoveMemberRequest();
+  UnsubscribeMemberRequest::default_instance_ = new UnsubscribeMemberRequest();
+  SendMessageRequest::default_instance_ = new SendMessageRequest();
+  UpdateChannelStateRequest::default_instance_ = new UpdateChannelStateRequest();
+  UpdateMemberStateRequest::default_instance_ = new UpdateMemberStateRequest();
+  DissolveRequest::default_instance_ = new DissolveRequest();
+  SetRolesRequest::default_instance_ = new SetRolesRequest();
+  JoinNotification::default_instance_ = new JoinNotification();
+  MemberAddedNotification::default_instance_ = new MemberAddedNotification();
+  LeaveNotification::default_instance_ = new LeaveNotification();
+  MemberRemovedNotification::default_instance_ = new MemberRemovedNotification();
+  SendMessageNotification::default_instance_ = new SendMessageNotification();
+  UpdateChannelStateNotification::default_instance_ = new UpdateChannelStateNotification();
+  UpdateMemberStateNotification::default_instance_ = new UpdateMemberStateNotification();
+  AddMemberRequest::default_instance_->InitAsDefaultInstance();
+  RemoveMemberRequest::default_instance_->InitAsDefaultInstance();
+  UnsubscribeMemberRequest::default_instance_->InitAsDefaultInstance();
+  SendMessageRequest::default_instance_->InitAsDefaultInstance();
+  UpdateChannelStateRequest::default_instance_->InitAsDefaultInstance();
+  UpdateMemberStateRequest::default_instance_->InitAsDefaultInstance();
+  DissolveRequest::default_instance_->InitAsDefaultInstance();
+  SetRolesRequest::default_instance_->InitAsDefaultInstance();
+  JoinNotification::default_instance_->InitAsDefaultInstance();
+  MemberAddedNotification::default_instance_->InitAsDefaultInstance();
+  LeaveNotification::default_instance_->InitAsDefaultInstance();
+  MemberRemovedNotification::default_instance_->InitAsDefaultInstance();
+  SendMessageNotification::default_instance_->InitAsDefaultInstance();
+  UpdateChannelStateNotification::default_instance_->InitAsDefaultInstance();
+  UpdateMemberStateNotification::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_channel_5fservice_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_channel_5fservice_2eproto {
+  StaticDescriptorInitializer_channel_5fservice_2eproto() {
+    protobuf_AddDesc_channel_5fservice_2eproto();
+  }
+} static_descriptor_initializer_channel_5fservice_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AddMemberRequest::kAgentIdFieldNumber;
+const int AddMemberRequest::kMemberIdentityFieldNumber;
+const int AddMemberRequest::kMemberStateFieldNumber;
+const int AddMemberRequest::kObjectIdFieldNumber;
+const int AddMemberRequest::kSubscribeFieldNumber;
+#endif  // !_MSC_VER
+
+AddMemberRequest::AddMemberRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.AddMemberRequest)
+}
+
+void AddMemberRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  member_identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance());
+  member_state_ = const_cast< ::bgs::protocol::channel::v1::MemberState*>(&::bgs::protocol::channel::v1::MemberState::default_instance());
+}
+
+AddMemberRequest::AddMemberRequest(const AddMemberRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.AddMemberRequest)
+}
+
+void AddMemberRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  member_identity_ = NULL;
+  member_state_ = NULL;
+  object_id_ = GOOGLE_ULONGLONG(0);
+  subscribe_ = true;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AddMemberRequest::~AddMemberRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.AddMemberRequest)
+  SharedDtor();
+}
+
+void AddMemberRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete member_identity_;
+    delete member_state_;
+  }
+}
+
+void AddMemberRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AddMemberRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AddMemberRequest_descriptor_;
+}
+
+const AddMemberRequest& AddMemberRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
+  return *default_instance_;
+}
+
+AddMemberRequest* AddMemberRequest::default_instance_ = NULL;
+
+AddMemberRequest* AddMemberRequest::New() const {
+  return new AddMemberRequest;
+}
+
+void AddMemberRequest::Clear() {
+  if (_has_bits_[0 / 32] & 31) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_member_identity()) {
+      if (member_identity_ != NULL) member_identity_->::bgs::protocol::Identity::Clear();
+    }
+    if (has_member_state()) {
+      if (member_state_ != NULL) member_state_->::bgs::protocol::channel::v1::MemberState::Clear();
+    }
+    object_id_ = GOOGLE_ULONGLONG(0);
+    subscribe_ = true;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AddMemberRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.AddMemberRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_member_identity;
+        break;
+      }
+
+      // required .bgs.protocol.Identity member_identity = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_member_identity:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member_identity()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_member_state;
+        break;
+      }
+
+      // required .bgs.protocol.channel.v1.MemberState member_state = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_member_state:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_object_id;
+        break;
+      }
+
+      // required uint64 object_id = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_object_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &object_id_)));
+          set_has_object_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_subscribe;
+        break;
+      }
+
+      // optional bool subscribe = 5 [default = true];
+      case 5: {
+        if (tag == 40) {
+         parse_subscribe:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &subscribe_)));
+          set_has_subscribe();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.AddMemberRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.AddMemberRequest)
+  return false;
+#undef DO_
+}
+
+void AddMemberRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.AddMemberRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.Identity member_identity = 2;
+  if (has_member_identity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->member_identity(), output);
+  }
+
+  // required .bgs.protocol.channel.v1.MemberState member_state = 3;
+  if (has_member_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->member_state(), output);
+  }
+
+  // required uint64 object_id = 4;
+  if (has_object_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->object_id(), output);
+  }
+
+  // optional bool subscribe = 5 [default = true];
+  if (has_subscribe()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->subscribe(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.AddMemberRequest)
+}
+
+::google::protobuf::uint8* AddMemberRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.AddMemberRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.Identity member_identity = 2;
+  if (has_member_identity()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->member_identity(), target);
+  }
+
+  // required .bgs.protocol.channel.v1.MemberState member_state = 3;
+  if (has_member_state()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->member_state(), target);
+  }
+
+  // required uint64 object_id = 4;
+  if (has_object_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->object_id(), target);
+  }
+
+  // optional bool subscribe = 5 [default = true];
+  if (has_subscribe()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->subscribe(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.AddMemberRequest)
+  return target;
+}
+
+int AddMemberRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.Identity member_identity = 2;
+    if (has_member_identity()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member_identity());
+    }
+
+    // required .bgs.protocol.channel.v1.MemberState member_state = 3;
+    if (has_member_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member_state());
+    }
+
+    // required uint64 object_id = 4;
+    if (has_object_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->object_id());
+    }
+
+    // optional bool subscribe = 5 [default = true];
+    if (has_subscribe()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AddMemberRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AddMemberRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AddMemberRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AddMemberRequest::MergeFrom(const AddMemberRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_member_identity()) {
+      mutable_member_identity()->::bgs::protocol::Identity::MergeFrom(from.member_identity());
+    }
+    if (from.has_member_state()) {
+      mutable_member_state()->::bgs::protocol::channel::v1::MemberState::MergeFrom(from.member_state());
+    }
+    if (from.has_object_id()) {
+      set_object_id(from.object_id());
+    }
+    if (from.has_subscribe()) {
+      set_subscribe(from.subscribe());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AddMemberRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AddMemberRequest::CopyFrom(const AddMemberRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AddMemberRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x0000000e) != 0x0000000e) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_member_identity()) {
+    if (!this->member_identity().IsInitialized()) return false;
+  }
+  if (has_member_state()) {
+    if (!this->member_state().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AddMemberRequest::Swap(AddMemberRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(member_identity_, other->member_identity_);
+    std::swap(member_state_, other->member_state_);
+    std::swap(object_id_, other->object_id_);
+    std::swap(subscribe_, other->subscribe_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AddMemberRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AddMemberRequest_descriptor_;
+  metadata.reflection = AddMemberRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RemoveMemberRequest::kAgentIdFieldNumber;
+const int RemoveMemberRequest::kMemberIdFieldNumber;
+const int RemoveMemberRequest::kReasonFieldNumber;
+#endif  // !_MSC_VER
+
+RemoveMemberRequest::RemoveMemberRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.RemoveMemberRequest)
+}
+
+void RemoveMemberRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  member_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+RemoveMemberRequest::RemoveMemberRequest(const RemoveMemberRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.RemoveMemberRequest)
+}
+
+void RemoveMemberRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  member_id_ = NULL;
+  reason_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RemoveMemberRequest::~RemoveMemberRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.RemoveMemberRequest)
+  SharedDtor();
+}
+
+void RemoveMemberRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete member_id_;
+  }
+}
+
+void RemoveMemberRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RemoveMemberRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RemoveMemberRequest_descriptor_;
+}
+
+const RemoveMemberRequest& RemoveMemberRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
+  return *default_instance_;
+}
+
+RemoveMemberRequest* RemoveMemberRequest::default_instance_ = NULL;
+
+RemoveMemberRequest* RemoveMemberRequest::New() const {
+  return new RemoveMemberRequest;
+}
+
+void RemoveMemberRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_member_id()) {
+      if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear();
+    }
+    reason_ = 0u;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RemoveMemberRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.RemoveMemberRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_member_id;
+        break;
+      }
+
+      // required .bgs.protocol.EntityId member_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_member_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_reason;
+        break;
+      }
+
+      // optional uint32 reason = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_reason:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &reason_)));
+          set_has_reason();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.RemoveMemberRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.RemoveMemberRequest)
+  return false;
+#undef DO_
+}
+
+void RemoveMemberRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.RemoveMemberRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.EntityId member_id = 2;
+  if (has_member_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->member_id(), output);
+  }
+
+  // optional uint32 reason = 3;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->reason(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.RemoveMemberRequest)
+}
+
+::google::protobuf::uint8* RemoveMemberRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.RemoveMemberRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.EntityId member_id = 2;
+  if (has_member_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->member_id(), target);
+  }
+
+  // optional uint32 reason = 3;
+  if (has_reason()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->reason(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.RemoveMemberRequest)
+  return target;
+}
+
+int RemoveMemberRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.EntityId member_id = 2;
+    if (has_member_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member_id());
+    }
+
+    // optional uint32 reason = 3;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->reason());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RemoveMemberRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RemoveMemberRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RemoveMemberRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RemoveMemberRequest::MergeFrom(const RemoveMemberRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_member_id()) {
+      mutable_member_id()->::bgs::protocol::EntityId::MergeFrom(from.member_id());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RemoveMemberRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RemoveMemberRequest::CopyFrom(const RemoveMemberRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RemoveMemberRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_member_id()) {
+    if (!this->member_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void RemoveMemberRequest::Swap(RemoveMemberRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(member_id_, other->member_id_);
+    std::swap(reason_, other->reason_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RemoveMemberRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RemoveMemberRequest_descriptor_;
+  metadata.reflection = RemoveMemberRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UnsubscribeMemberRequest::kAgentIdFieldNumber;
+const int UnsubscribeMemberRequest::kMemberIdFieldNumber;
+#endif  // !_MSC_VER
+
+UnsubscribeMemberRequest::UnsubscribeMemberRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.UnsubscribeMemberRequest)
+}
+
+void UnsubscribeMemberRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  member_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+UnsubscribeMemberRequest::UnsubscribeMemberRequest(const UnsubscribeMemberRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.UnsubscribeMemberRequest)
+}
+
+void UnsubscribeMemberRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  member_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UnsubscribeMemberRequest::~UnsubscribeMemberRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.UnsubscribeMemberRequest)
+  SharedDtor();
+}
+
+void UnsubscribeMemberRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete member_id_;
+  }
+}
+
+void UnsubscribeMemberRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UnsubscribeMemberRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UnsubscribeMemberRequest_descriptor_;
+}
+
+const UnsubscribeMemberRequest& UnsubscribeMemberRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
+  return *default_instance_;
+}
+
+UnsubscribeMemberRequest* UnsubscribeMemberRequest::default_instance_ = NULL;
+
+UnsubscribeMemberRequest* UnsubscribeMemberRequest::New() const {
+  return new UnsubscribeMemberRequest;
+}
+
+void UnsubscribeMemberRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_member_id()) {
+      if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UnsubscribeMemberRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.UnsubscribeMemberRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_member_id;
+        break;
+      }
+
+      // required .bgs.protocol.EntityId member_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_member_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.UnsubscribeMemberRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.UnsubscribeMemberRequest)
+  return false;
+#undef DO_
+}
+
+void UnsubscribeMemberRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.UnsubscribeMemberRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.EntityId member_id = 2;
+  if (has_member_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->member_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.UnsubscribeMemberRequest)
+}
+
+::google::protobuf::uint8* UnsubscribeMemberRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.UnsubscribeMemberRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.EntityId member_id = 2;
+  if (has_member_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->member_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.UnsubscribeMemberRequest)
+  return target;
+}
+
+int UnsubscribeMemberRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.EntityId member_id = 2;
+    if (has_member_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UnsubscribeMemberRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UnsubscribeMemberRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UnsubscribeMemberRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UnsubscribeMemberRequest::MergeFrom(const UnsubscribeMemberRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_member_id()) {
+      mutable_member_id()->::bgs::protocol::EntityId::MergeFrom(from.member_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UnsubscribeMemberRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UnsubscribeMemberRequest::CopyFrom(const UnsubscribeMemberRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UnsubscribeMemberRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_member_id()) {
+    if (!this->member_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UnsubscribeMemberRequest::Swap(UnsubscribeMemberRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(member_id_, other->member_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UnsubscribeMemberRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UnsubscribeMemberRequest_descriptor_;
+  metadata.reflection = UnsubscribeMemberRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SendMessageRequest::kAgentIdFieldNumber;
+const int SendMessageRequest::kMessageFieldNumber;
+const int SendMessageRequest::kRequiredPrivilegesFieldNumber;
+#endif  // !_MSC_VER
+
+SendMessageRequest::SendMessageRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.SendMessageRequest)
+}
+
+void SendMessageRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  message_ = const_cast< ::bgs::protocol::channel::v1::Message*>(&::bgs::protocol::channel::v1::Message::default_instance());
+}
+
+SendMessageRequest::SendMessageRequest(const SendMessageRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.SendMessageRequest)
+}
+
+void SendMessageRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  message_ = NULL;
+  required_privileges_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SendMessageRequest::~SendMessageRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.SendMessageRequest)
+  SharedDtor();
+}
+
+void SendMessageRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete message_;
+  }
+}
+
+void SendMessageRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SendMessageRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SendMessageRequest_descriptor_;
+}
+
+const SendMessageRequest& SendMessageRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SendMessageRequest* SendMessageRequest::default_instance_ = NULL;
+
+SendMessageRequest* SendMessageRequest::New() const {
+  return new SendMessageRequest;
+}
+
+void SendMessageRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_message()) {
+      if (message_ != NULL) message_->::bgs::protocol::channel::v1::Message::Clear();
+    }
+    required_privileges_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SendMessageRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.SendMessageRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_message;
+        break;
+      }
+
+      // required .bgs.protocol.channel.v1.Message message = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_message:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_message()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_required_privileges;
+        break;
+      }
+
+      // optional uint64 required_privileges = 3 [default = 0];
+      case 3: {
+        if (tag == 24) {
+         parse_required_privileges:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &required_privileges_)));
+          set_has_required_privileges();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.SendMessageRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.SendMessageRequest)
+  return false;
+#undef DO_
+}
+
+void SendMessageRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.SendMessageRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.channel.v1.Message message = 2;
+  if (has_message()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->message(), output);
+  }
+
+  // optional uint64 required_privileges = 3 [default = 0];
+  if (has_required_privileges()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->required_privileges(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.SendMessageRequest)
+}
+
+::google::protobuf::uint8* SendMessageRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.SendMessageRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.channel.v1.Message message = 2;
+  if (has_message()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->message(), target);
+  }
+
+  // optional uint64 required_privileges = 3 [default = 0];
+  if (has_required_privileges()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->required_privileges(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.SendMessageRequest)
+  return target;
+}
+
+int SendMessageRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.channel.v1.Message message = 2;
+    if (has_message()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->message());
+    }
+
+    // optional uint64 required_privileges = 3 [default = 0];
+    if (has_required_privileges()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->required_privileges());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SendMessageRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SendMessageRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SendMessageRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SendMessageRequest::MergeFrom(const SendMessageRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_message()) {
+      mutable_message()->::bgs::protocol::channel::v1::Message::MergeFrom(from.message());
+    }
+    if (from.has_required_privileges()) {
+      set_required_privileges(from.required_privileges());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SendMessageRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SendMessageRequest::CopyFrom(const SendMessageRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SendMessageRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_message()) {
+    if (!this->message().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SendMessageRequest::Swap(SendMessageRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(message_, other->message_);
+    std::swap(required_privileges_, other->required_privileges_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SendMessageRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SendMessageRequest_descriptor_;
+  metadata.reflection = SendMessageRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UpdateChannelStateRequest::kAgentIdFieldNumber;
+const int UpdateChannelStateRequest::kStateChangeFieldNumber;
+#endif  // !_MSC_VER
+
+UpdateChannelStateRequest::UpdateChannelStateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.UpdateChannelStateRequest)
+}
+
+void UpdateChannelStateRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  state_change_ = const_cast< ::bgs::protocol::channel::v1::ChannelState*>(&::bgs::protocol::channel::v1::ChannelState::default_instance());
+}
+
+UpdateChannelStateRequest::UpdateChannelStateRequest(const UpdateChannelStateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.UpdateChannelStateRequest)
+}
+
+void UpdateChannelStateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  state_change_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UpdateChannelStateRequest::~UpdateChannelStateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.UpdateChannelStateRequest)
+  SharedDtor();
+}
+
+void UpdateChannelStateRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete state_change_;
+  }
+}
+
+void UpdateChannelStateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UpdateChannelStateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UpdateChannelStateRequest_descriptor_;
+}
+
+const UpdateChannelStateRequest& UpdateChannelStateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
+  return *default_instance_;
+}
+
+UpdateChannelStateRequest* UpdateChannelStateRequest::default_instance_ = NULL;
+
+UpdateChannelStateRequest* UpdateChannelStateRequest::New() const {
+  return new UpdateChannelStateRequest;
+}
+
+void UpdateChannelStateRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_state_change()) {
+      if (state_change_ != NULL) state_change_->::bgs::protocol::channel::v1::ChannelState::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UpdateChannelStateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.UpdateChannelStateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_state_change;
+        break;
+      }
+
+      // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_state_change:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_state_change()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.UpdateChannelStateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.UpdateChannelStateRequest)
+  return false;
+#undef DO_
+}
+
+void UpdateChannelStateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.UpdateChannelStateRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
+  if (has_state_change()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->state_change(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.UpdateChannelStateRequest)
+}
+
+::google::protobuf::uint8* UpdateChannelStateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.UpdateChannelStateRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
+  if (has_state_change()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->state_change(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.UpdateChannelStateRequest)
+  return target;
+}
+
+int UpdateChannelStateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
+    if (has_state_change()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->state_change());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UpdateChannelStateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UpdateChannelStateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateChannelStateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UpdateChannelStateRequest::MergeFrom(const UpdateChannelStateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_state_change()) {
+      mutable_state_change()->::bgs::protocol::channel::v1::ChannelState::MergeFrom(from.state_change());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UpdateChannelStateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UpdateChannelStateRequest::CopyFrom(const UpdateChannelStateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UpdateChannelStateRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_state_change()) {
+    if (!this->state_change().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UpdateChannelStateRequest::Swap(UpdateChannelStateRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(state_change_, other->state_change_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UpdateChannelStateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UpdateChannelStateRequest_descriptor_;
+  metadata.reflection = UpdateChannelStateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UpdateMemberStateRequest::kAgentIdFieldNumber;
+const int UpdateMemberStateRequest::kStateChangeFieldNumber;
+const int UpdateMemberStateRequest::kRemovedRoleFieldNumber;
+#endif  // !_MSC_VER
+
+UpdateMemberStateRequest::UpdateMemberStateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.UpdateMemberStateRequest)
+}
+
+void UpdateMemberStateRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+UpdateMemberStateRequest::UpdateMemberStateRequest(const UpdateMemberStateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.UpdateMemberStateRequest)
+}
+
+void UpdateMemberStateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UpdateMemberStateRequest::~UpdateMemberStateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.UpdateMemberStateRequest)
+  SharedDtor();
+}
+
+void UpdateMemberStateRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void UpdateMemberStateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UpdateMemberStateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UpdateMemberStateRequest_descriptor_;
+}
+
+const UpdateMemberStateRequest& UpdateMemberStateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
+  return *default_instance_;
+}
+
+UpdateMemberStateRequest* UpdateMemberStateRequest::default_instance_ = NULL;
+
+UpdateMemberStateRequest* UpdateMemberStateRequest::New() const {
+  return new UpdateMemberStateRequest;
+}
+
+void UpdateMemberStateRequest::Clear() {
+  if (has_agent_id()) {
+    if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  }
+  state_change_.Clear();
+  removed_role_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UpdateMemberStateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.UpdateMemberStateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_state_change;
+        break;
+      }
+
+      // repeated .bgs.protocol.channel.v1.Member state_change = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_state_change:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_state_change()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_state_change;
+        if (input->ExpectTag(26)) goto parse_removed_role;
+        break;
+      }
+
+      // repeated uint32 removed_role = 3 [packed = true];
+      case 3: {
+        if (tag == 26) {
+         parse_removed_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_removed_role())));
+        } else if (tag == 24) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 26, input, this->mutable_removed_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.UpdateMemberStateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.UpdateMemberStateRequest)
+  return false;
+#undef DO_
+}
+
+void UpdateMemberStateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.UpdateMemberStateRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // repeated .bgs.protocol.channel.v1.Member state_change = 2;
+  for (int i = 0; i < this->state_change_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->state_change(i), output);
+  }
+
+  // repeated uint32 removed_role = 3 [packed = true];
+  if (this->removed_role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_removed_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->removed_role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->removed_role(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.UpdateMemberStateRequest)
+}
+
+::google::protobuf::uint8* UpdateMemberStateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.UpdateMemberStateRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // repeated .bgs.protocol.channel.v1.Member state_change = 2;
+  for (int i = 0; i < this->state_change_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->state_change(i), target);
+  }
+
+  // repeated uint32 removed_role = 3 [packed = true];
+  if (this->removed_role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      3,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _removed_role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->removed_role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->removed_role(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.UpdateMemberStateRequest)
+  return target;
+}
+
+int UpdateMemberStateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+  }
+  // repeated .bgs.protocol.channel.v1.Member state_change = 2;
+  total_size += 1 * this->state_change_size();
+  for (int i = 0; i < this->state_change_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->state_change(i));
+  }
+
+  // repeated uint32 removed_role = 3 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->removed_role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->removed_role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _removed_role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UpdateMemberStateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UpdateMemberStateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateMemberStateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UpdateMemberStateRequest::MergeFrom(const UpdateMemberStateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  state_change_.MergeFrom(from.state_change_);
+  removed_role_.MergeFrom(from.removed_role_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UpdateMemberStateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UpdateMemberStateRequest::CopyFrom(const UpdateMemberStateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UpdateMemberStateRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->state_change())) return false;
+  return true;
+}
+
+void UpdateMemberStateRequest::Swap(UpdateMemberStateRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    state_change_.Swap(&other->state_change_);
+    removed_role_.Swap(&other->removed_role_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UpdateMemberStateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UpdateMemberStateRequest_descriptor_;
+  metadata.reflection = UpdateMemberStateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int DissolveRequest::kAgentIdFieldNumber;
+const int DissolveRequest::kReasonFieldNumber;
+#endif  // !_MSC_VER
+
+DissolveRequest::DissolveRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.DissolveRequest)
+}
+
+void DissolveRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+DissolveRequest::DissolveRequest(const DissolveRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.DissolveRequest)
+}
+
+void DissolveRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  reason_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+DissolveRequest::~DissolveRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.DissolveRequest)
+  SharedDtor();
+}
+
+void DissolveRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void DissolveRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* DissolveRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return DissolveRequest_descriptor_;
+}
+
+const DissolveRequest& DissolveRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
+  return *default_instance_;
+}
+
+DissolveRequest* DissolveRequest::default_instance_ = NULL;
+
+DissolveRequest* DissolveRequest::New() const {
+  return new DissolveRequest;
+}
+
+void DissolveRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    reason_ = 0u;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool DissolveRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.DissolveRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_reason;
+        break;
+      }
+
+      // optional uint32 reason = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_reason:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &reason_)));
+          set_has_reason();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.DissolveRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.DissolveRequest)
+  return false;
+#undef DO_
+}
+
+void DissolveRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.DissolveRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint32 reason = 2;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->reason(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.DissolveRequest)
+}
+
+::google::protobuf::uint8* DissolveRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.DissolveRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint32 reason = 2;
+  if (has_reason()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->reason(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.DissolveRequest)
+  return target;
+}
+
+int DissolveRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint32 reason = 2;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->reason());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void DissolveRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const DissolveRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const DissolveRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void DissolveRequest::MergeFrom(const DissolveRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void DissolveRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void DissolveRequest::CopyFrom(const DissolveRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DissolveRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void DissolveRequest::Swap(DissolveRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(reason_, other->reason_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata DissolveRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = DissolveRequest_descriptor_;
+  metadata.reflection = DissolveRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SetRolesRequest::kAgentIdFieldNumber;
+const int SetRolesRequest::kRoleFieldNumber;
+const int SetRolesRequest::kMemberIdFieldNumber;
+#endif  // !_MSC_VER
+
+SetRolesRequest::SetRolesRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.SetRolesRequest)
+}
+
+void SetRolesRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+SetRolesRequest::SetRolesRequest(const SetRolesRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.SetRolesRequest)
+}
+
+void SetRolesRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SetRolesRequest::~SetRolesRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.SetRolesRequest)
+  SharedDtor();
+}
+
+void SetRolesRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void SetRolesRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SetRolesRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SetRolesRequest_descriptor_;
+}
+
+const SetRolesRequest& SetRolesRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SetRolesRequest* SetRolesRequest::default_instance_ = NULL;
+
+SetRolesRequest* SetRolesRequest::New() const {
+  return new SetRolesRequest;
+}
+
+void SetRolesRequest::Clear() {
+  if (has_agent_id()) {
+    if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  }
+  role_.Clear();
+  member_id_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SetRolesRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.SetRolesRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_role;
+        break;
+      }
+
+      // repeated uint32 role = 2 [packed = true];
+      case 2: {
+        if (tag == 18) {
+         parse_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_role())));
+        } else if (tag == 16) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 18, input, this->mutable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_member_id;
+        break;
+      }
+
+      // repeated .bgs.protocol.EntityId member_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_member_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_member_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_member_id;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.SetRolesRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.SetRolesRequest)
+  return false;
+#undef DO_
+}
+
+void SetRolesRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.SetRolesRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // repeated uint32 role = 2 [packed = true];
+  if (this->role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->role(i), output);
+  }
+
+  // repeated .bgs.protocol.EntityId member_id = 3;
+  for (int i = 0; i < this->member_id_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->member_id(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.SetRolesRequest)
+}
+
+::google::protobuf::uint8* SetRolesRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.SetRolesRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // repeated uint32 role = 2 [packed = true];
+  if (this->role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      2,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->role(i), target);
+  }
+
+  // repeated .bgs.protocol.EntityId member_id = 3;
+  for (int i = 0; i < this->member_id_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->member_id(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.SetRolesRequest)
+  return target;
+}
+
+int SetRolesRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+  }
+  // repeated uint32 role = 2 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated .bgs.protocol.EntityId member_id = 3;
+  total_size += 1 * this->member_id_size();
+  for (int i = 0; i < this->member_id_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->member_id(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SetRolesRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SetRolesRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SetRolesRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SetRolesRequest::MergeFrom(const SetRolesRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  role_.MergeFrom(from.role_);
+  member_id_.MergeFrom(from.member_id_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SetRolesRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SetRolesRequest::CopyFrom(const SetRolesRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SetRolesRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->member_id())) return false;
+  return true;
+}
+
+void SetRolesRequest::Swap(SetRolesRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    role_.Swap(&other->role_);
+    member_id_.Swap(&other->member_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SetRolesRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SetRolesRequest_descriptor_;
+  metadata.reflection = SetRolesRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int JoinNotification::kSelfFieldNumber;
+const int JoinNotification::kMemberFieldNumber;
+const int JoinNotification::kChannelStateFieldNumber;
+const int JoinNotification::kChannelIdFieldNumber;
+const int JoinNotification::kSubscriberFieldNumber;
+#endif  // !_MSC_VER
+
+JoinNotification::JoinNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.JoinNotification)
+}
+
+void JoinNotification::InitAsDefaultInstance() {
+  self_ = const_cast< ::bgs::protocol::channel::v1::Member*>(&::bgs::protocol::channel::v1::Member::default_instance());
+  channel_state_ = const_cast< ::bgs::protocol::channel::v1::ChannelState*>(&::bgs::protocol::channel::v1::ChannelState::default_instance());
+  channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance());
+  subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
+}
+
+JoinNotification::JoinNotification(const JoinNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.JoinNotification)
+}
+
+void JoinNotification::SharedCtor() {
+  _cached_size_ = 0;
+  self_ = NULL;
+  channel_state_ = NULL;
+  channel_id_ = NULL;
+  subscriber_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+JoinNotification::~JoinNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.JoinNotification)
+  SharedDtor();
+}
+
+void JoinNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete self_;
+    delete channel_state_;
+    delete channel_id_;
+    delete subscriber_;
+  }
+}
+
+void JoinNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* JoinNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return JoinNotification_descriptor_;
+}
+
+const JoinNotification& JoinNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
+  return *default_instance_;
+}
+
+JoinNotification* JoinNotification::default_instance_ = NULL;
+
+JoinNotification* JoinNotification::New() const {
+  return new JoinNotification;
+}
+
+void JoinNotification::Clear() {
+  if (_has_bits_[0 / 32] & 29) {
+    if (has_self()) {
+      if (self_ != NULL) self_->::bgs::protocol::channel::v1::Member::Clear();
+    }
+    if (has_channel_state()) {
+      if (channel_state_ != NULL) channel_state_->::bgs::protocol::channel::v1::ChannelState::Clear();
+    }
+    if (has_channel_id()) {
+      if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
+    }
+    if (has_subscriber()) {
+      if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
+    }
+  }
+  member_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool JoinNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.JoinNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.channel.v1.Member self = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_self()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_member;
+        break;
+      }
+
+      // repeated .bgs.protocol.channel.v1.Member member = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_member:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_member()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_member;
+        if (input->ExpectTag(26)) goto parse_channel_state;
+        break;
+      }
+
+      // required .bgs.protocol.channel.v1.ChannelState channel_state = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_channel_state:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_channel_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_channel_id;
+        break;
+      }
+
+      // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_channel_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_channel_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_subscriber;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_subscriber:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.JoinNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.JoinNotification)
+  return false;
+#undef DO_
+}
+
+void JoinNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.JoinNotification)
+  // optional .bgs.protocol.channel.v1.Member self = 1;
+  if (has_self()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->self(), output);
+  }
+
+  // repeated .bgs.protocol.channel.v1.Member member = 2;
+  for (int i = 0; i < this->member_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->member(i), output);
+  }
+
+  // required .bgs.protocol.channel.v1.ChannelState channel_state = 3;
+  if (has_channel_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->channel_state(), output);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+  if (has_channel_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->channel_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+  if (has_subscriber()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->subscriber(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.JoinNotification)
+}
+
+::google::protobuf::uint8* JoinNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.JoinNotification)
+  // optional .bgs.protocol.channel.v1.Member self = 1;
+  if (has_self()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->self(), target);
+  }
+
+  // repeated .bgs.protocol.channel.v1.Member member = 2;
+  for (int i = 0; i < this->member_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->member(i), target);
+  }
+
+  // required .bgs.protocol.channel.v1.ChannelState channel_state = 3;
+  if (has_channel_state()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->channel_state(), target);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+  if (has_channel_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->channel_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+  if (has_subscriber()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->subscriber(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.JoinNotification)
+  return target;
+}
+
+int JoinNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.channel.v1.Member self = 1;
+    if (has_self()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->self());
+    }
+
+    // required .bgs.protocol.channel.v1.ChannelState channel_state = 3;
+    if (has_channel_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->channel_state());
+    }
+
+    // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+    if (has_channel_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->channel_id());
+    }
+
+    // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+    if (has_subscriber()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber());
+    }
+
+  }
+  // repeated .bgs.protocol.channel.v1.Member member = 2;
+  total_size += 1 * this->member_size();
+  for (int i = 0; i < this->member_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->member(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void JoinNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const JoinNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const JoinNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void JoinNotification::MergeFrom(const JoinNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  member_.MergeFrom(from.member_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_self()) {
+      mutable_self()->::bgs::protocol::channel::v1::Member::MergeFrom(from.self());
+    }
+    if (from.has_channel_state()) {
+      mutable_channel_state()->::bgs::protocol::channel::v1::ChannelState::MergeFrom(from.channel_state());
+    }
+    if (from.has_channel_id()) {
+      mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id());
+    }
+    if (from.has_subscriber()) {
+      mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void JoinNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void JoinNotification::CopyFrom(const JoinNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool JoinNotification::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000004) != 0x00000004) return false;
+
+  if (has_self()) {
+    if (!this->self().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->member())) return false;
+  if (has_channel_state()) {
+    if (!this->channel_state().IsInitialized()) return false;
+  }
+  if (has_channel_id()) {
+    if (!this->channel_id().IsInitialized()) return false;
+  }
+  if (has_subscriber()) {
+    if (!this->subscriber().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void JoinNotification::Swap(JoinNotification* other) {
+  if (other != this) {
+    std::swap(self_, other->self_);
+    member_.Swap(&other->member_);
+    std::swap(channel_state_, other->channel_state_);
+    std::swap(channel_id_, other->channel_id_);
+    std::swap(subscriber_, other->subscriber_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata JoinNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = JoinNotification_descriptor_;
+  metadata.reflection = JoinNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemberAddedNotification::kMemberFieldNumber;
+const int MemberAddedNotification::kChannelIdFieldNumber;
+const int MemberAddedNotification::kSubscriberFieldNumber;
+#endif  // !_MSC_VER
+
+MemberAddedNotification::MemberAddedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.MemberAddedNotification)
+}
+
+void MemberAddedNotification::InitAsDefaultInstance() {
+  member_ = const_cast< ::bgs::protocol::channel::v1::Member*>(&::bgs::protocol::channel::v1::Member::default_instance());
+  channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance());
+  subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
+}
+
+MemberAddedNotification::MemberAddedNotification(const MemberAddedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.MemberAddedNotification)
+}
+
+void MemberAddedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  member_ = NULL;
+  channel_id_ = NULL;
+  subscriber_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemberAddedNotification::~MemberAddedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.MemberAddedNotification)
+  SharedDtor();
+}
+
+void MemberAddedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete member_;
+    delete channel_id_;
+    delete subscriber_;
+  }
+}
+
+void MemberAddedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemberAddedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemberAddedNotification_descriptor_;
+}
+
+const MemberAddedNotification& MemberAddedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
+  return *default_instance_;
+}
+
+MemberAddedNotification* MemberAddedNotification::default_instance_ = NULL;
+
+MemberAddedNotification* MemberAddedNotification::New() const {
+  return new MemberAddedNotification;
+}
+
+void MemberAddedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_member()) {
+      if (member_ != NULL) member_->::bgs::protocol::channel::v1::Member::Clear();
+    }
+    if (has_channel_id()) {
+      if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
+    }
+    if (has_subscriber()) {
+      if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemberAddedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.MemberAddedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.channel.v1.Member member = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_channel_id;
+        break;
+      }
+
+      // optional .bgs.protocol.channel.v1.ChannelId channel_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_channel_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_channel_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_subscriber;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.Identity subscriber = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_subscriber:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.MemberAddedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.MemberAddedNotification)
+  return false;
+#undef DO_
+}
+
+void MemberAddedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.MemberAddedNotification)
+  // required .bgs.protocol.channel.v1.Member member = 1;
+  if (has_member()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->member(), output);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 2;
+  if (has_channel_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->channel_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 3;
+  if (has_subscriber()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->subscriber(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.MemberAddedNotification)
+}
+
+::google::protobuf::uint8* MemberAddedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.MemberAddedNotification)
+  // required .bgs.protocol.channel.v1.Member member = 1;
+  if (has_member()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->member(), target);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 2;
+  if (has_channel_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->channel_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 3;
+  if (has_subscriber()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->subscriber(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.MemberAddedNotification)
+  return target;
+}
+
+int MemberAddedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.channel.v1.Member member = 1;
+    if (has_member()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member());
+    }
+
+    // optional .bgs.protocol.channel.v1.ChannelId channel_id = 2;
+    if (has_channel_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->channel_id());
+    }
+
+    // optional .bgs.protocol.account.v1.Identity subscriber = 3;
+    if (has_subscriber()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemberAddedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemberAddedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemberAddedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemberAddedNotification::MergeFrom(const MemberAddedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_member()) {
+      mutable_member()->::bgs::protocol::channel::v1::Member::MergeFrom(from.member());
+    }
+    if (from.has_channel_id()) {
+      mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id());
+    }
+    if (from.has_subscriber()) {
+      mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemberAddedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemberAddedNotification::CopyFrom(const MemberAddedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemberAddedNotification::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_member()) {
+    if (!this->member().IsInitialized()) return false;
+  }
+  if (has_channel_id()) {
+    if (!this->channel_id().IsInitialized()) return false;
+  }
+  if (has_subscriber()) {
+    if (!this->subscriber().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void MemberAddedNotification::Swap(MemberAddedNotification* other) {
+  if (other != this) {
+    std::swap(member_, other->member_);
+    std::swap(channel_id_, other->channel_id_);
+    std::swap(subscriber_, other->subscriber_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemberAddedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemberAddedNotification_descriptor_;
+  metadata.reflection = MemberAddedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int LeaveNotification::kAgentIdFieldNumber;
+const int LeaveNotification::kMemberIdFieldNumber;
+const int LeaveNotification::kReasonFieldNumber;
+const int LeaveNotification::kChannelIdFieldNumber;
+const int LeaveNotification::kSubscriberFieldNumber;
+#endif  // !_MSC_VER
+
+LeaveNotification::LeaveNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.LeaveNotification)
+}
+
+void LeaveNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  member_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance());
+  subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
+}
+
+LeaveNotification::LeaveNotification(const LeaveNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.LeaveNotification)
+}
+
+void LeaveNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  member_id_ = NULL;
+  reason_ = 0u;
+  channel_id_ = NULL;
+  subscriber_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+LeaveNotification::~LeaveNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.LeaveNotification)
+  SharedDtor();
+}
+
+void LeaveNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete member_id_;
+    delete channel_id_;
+    delete subscriber_;
+  }
+}
+
+void LeaveNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* LeaveNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return LeaveNotification_descriptor_;
+}
+
+const LeaveNotification& LeaveNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
+  return *default_instance_;
+}
+
+LeaveNotification* LeaveNotification::default_instance_ = NULL;
+
+LeaveNotification* LeaveNotification::New() const {
+  return new LeaveNotification;
+}
+
+void LeaveNotification::Clear() {
+  if (_has_bits_[0 / 32] & 31) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_member_id()) {
+      if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear();
+    }
+    reason_ = 0u;
+    if (has_channel_id()) {
+      if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
+    }
+    if (has_subscriber()) {
+      if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool LeaveNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.LeaveNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_member_id;
+        break;
+      }
+
+      // required .bgs.protocol.EntityId member_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_member_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_reason;
+        break;
+      }
+
+      // optional uint32 reason = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_reason:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &reason_)));
+          set_has_reason();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_channel_id;
+        break;
+      }
+
+      // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_channel_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_channel_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_subscriber;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_subscriber:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.LeaveNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.LeaveNotification)
+  return false;
+#undef DO_
+}
+
+void LeaveNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.LeaveNotification)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.EntityId member_id = 2;
+  if (has_member_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->member_id(), output);
+  }
+
+  // optional uint32 reason = 3;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->reason(), output);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+  if (has_channel_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->channel_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+  if (has_subscriber()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->subscriber(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.LeaveNotification)
+}
+
+::google::protobuf::uint8* LeaveNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.LeaveNotification)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.EntityId member_id = 2;
+  if (has_member_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->member_id(), target);
+  }
+
+  // optional uint32 reason = 3;
+  if (has_reason()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->reason(), target);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+  if (has_channel_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->channel_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+  if (has_subscriber()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->subscriber(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.LeaveNotification)
+  return target;
+}
+
+int LeaveNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.EntityId member_id = 2;
+    if (has_member_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member_id());
+    }
+
+    // optional uint32 reason = 3;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->reason());
+    }
+
+    // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+    if (has_channel_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->channel_id());
+    }
+
+    // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+    if (has_subscriber()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void LeaveNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const LeaveNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const LeaveNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void LeaveNotification::MergeFrom(const LeaveNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_member_id()) {
+      mutable_member_id()->::bgs::protocol::EntityId::MergeFrom(from.member_id());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+    if (from.has_channel_id()) {
+      mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id());
+    }
+    if (from.has_subscriber()) {
+      mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void LeaveNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void LeaveNotification::CopyFrom(const LeaveNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool LeaveNotification::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_member_id()) {
+    if (!this->member_id().IsInitialized()) return false;
+  }
+  if (has_channel_id()) {
+    if (!this->channel_id().IsInitialized()) return false;
+  }
+  if (has_subscriber()) {
+    if (!this->subscriber().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void LeaveNotification::Swap(LeaveNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(member_id_, other->member_id_);
+    std::swap(reason_, other->reason_);
+    std::swap(channel_id_, other->channel_id_);
+    std::swap(subscriber_, other->subscriber_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata LeaveNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = LeaveNotification_descriptor_;
+  metadata.reflection = LeaveNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemberRemovedNotification::kAgentIdFieldNumber;
+const int MemberRemovedNotification::kMemberIdFieldNumber;
+const int MemberRemovedNotification::kReasonFieldNumber;
+const int MemberRemovedNotification::kChannelIdFieldNumber;
+const int MemberRemovedNotification::kSubscriberFieldNumber;
+#endif  // !_MSC_VER
+
+MemberRemovedNotification::MemberRemovedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.MemberRemovedNotification)
+}
+
+void MemberRemovedNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  member_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance());
+  subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
+}
+
+MemberRemovedNotification::MemberRemovedNotification(const MemberRemovedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.MemberRemovedNotification)
+}
+
+void MemberRemovedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  member_id_ = NULL;
+  reason_ = 0u;
+  channel_id_ = NULL;
+  subscriber_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemberRemovedNotification::~MemberRemovedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.MemberRemovedNotification)
+  SharedDtor();
+}
+
+void MemberRemovedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete member_id_;
+    delete channel_id_;
+    delete subscriber_;
+  }
+}
+
+void MemberRemovedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemberRemovedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemberRemovedNotification_descriptor_;
+}
+
+const MemberRemovedNotification& MemberRemovedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
+  return *default_instance_;
+}
+
+MemberRemovedNotification* MemberRemovedNotification::default_instance_ = NULL;
+
+MemberRemovedNotification* MemberRemovedNotification::New() const {
+  return new MemberRemovedNotification;
+}
+
+void MemberRemovedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 31) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_member_id()) {
+      if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear();
+    }
+    reason_ = 0u;
+    if (has_channel_id()) {
+      if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
+    }
+    if (has_subscriber()) {
+      if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemberRemovedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.MemberRemovedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_member_id;
+        break;
+      }
+
+      // required .bgs.protocol.EntityId member_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_member_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_member_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_reason;
+        break;
+      }
+
+      // optional uint32 reason = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_reason:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &reason_)));
+          set_has_reason();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_channel_id;
+        break;
+      }
+
+      // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_channel_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_channel_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_subscriber;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_subscriber:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.MemberRemovedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.MemberRemovedNotification)
+  return false;
+#undef DO_
+}
+
+void MemberRemovedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.MemberRemovedNotification)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.EntityId member_id = 2;
+  if (has_member_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->member_id(), output);
+  }
+
+  // optional uint32 reason = 3;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->reason(), output);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+  if (has_channel_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->channel_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+  if (has_subscriber()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->subscriber(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.MemberRemovedNotification)
+}
+
+::google::protobuf::uint8* MemberRemovedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.MemberRemovedNotification)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.EntityId member_id = 2;
+  if (has_member_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->member_id(), target);
+  }
+
+  // optional uint32 reason = 3;
+  if (has_reason()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->reason(), target);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+  if (has_channel_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->channel_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+  if (has_subscriber()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->subscriber(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.MemberRemovedNotification)
+  return target;
+}
+
+int MemberRemovedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.EntityId member_id = 2;
+    if (has_member_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->member_id());
+    }
+
+    // optional uint32 reason = 3;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->reason());
+    }
+
+    // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+    if (has_channel_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->channel_id());
+    }
+
+    // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+    if (has_subscriber()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemberRemovedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemberRemovedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemberRemovedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemberRemovedNotification::MergeFrom(const MemberRemovedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_member_id()) {
+      mutable_member_id()->::bgs::protocol::EntityId::MergeFrom(from.member_id());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+    if (from.has_channel_id()) {
+      mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id());
+    }
+    if (from.has_subscriber()) {
+      mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemberRemovedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemberRemovedNotification::CopyFrom(const MemberRemovedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemberRemovedNotification::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_member_id()) {
+    if (!this->member_id().IsInitialized()) return false;
+  }
+  if (has_channel_id()) {
+    if (!this->channel_id().IsInitialized()) return false;
+  }
+  if (has_subscriber()) {
+    if (!this->subscriber().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void MemberRemovedNotification::Swap(MemberRemovedNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(member_id_, other->member_id_);
+    std::swap(reason_, other->reason_);
+    std::swap(channel_id_, other->channel_id_);
+    std::swap(subscriber_, other->subscriber_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata MemberRemovedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemberRemovedNotification_descriptor_;
+  metadata.reflection = MemberRemovedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SendMessageNotification::kAgentIdFieldNumber;
+const int SendMessageNotification::kMessageFieldNumber;
+const int SendMessageNotification::kRequiredPrivilegesFieldNumber;
+const int SendMessageNotification::kIdentityFieldNumber;
+const int SendMessageNotification::kChannelIdFieldNumber;
+const int SendMessageNotification::kSubscriberFieldNumber;
+#endif  // !_MSC_VER
+
+SendMessageNotification::SendMessageNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.SendMessageNotification)
+}
+
+void SendMessageNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  message_ = const_cast< ::bgs::protocol::channel::v1::Message*>(&::bgs::protocol::channel::v1::Message::default_instance());
+  channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance());
+  subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
+}
+
+SendMessageNotification::SendMessageNotification(const SendMessageNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.SendMessageNotification)
+}
+
+void SendMessageNotification::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  message_ = NULL;
+  required_privileges_ = GOOGLE_ULONGLONG(0);
+  identity_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  channel_id_ = NULL;
+  subscriber_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SendMessageNotification::~SendMessageNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.SendMessageNotification)
+  SharedDtor();
+}
+
+void SendMessageNotification::SharedDtor() {
+  if (identity_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete identity_;
+  }
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete message_;
+    delete channel_id_;
+    delete subscriber_;
+  }
+}
+
+void SendMessageNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SendMessageNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SendMessageNotification_descriptor_;
+}
+
+const SendMessageNotification& SendMessageNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SendMessageNotification* SendMessageNotification::default_instance_ = NULL;
+
+SendMessageNotification* SendMessageNotification::New() const {
+  return new SendMessageNotification;
+}
+
+void SendMessageNotification::Clear() {
+  if (_has_bits_[0 / 32] & 63) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_message()) {
+      if (message_ != NULL) message_->::bgs::protocol::channel::v1::Message::Clear();
+    }
+    required_privileges_ = GOOGLE_ULONGLONG(0);
+    if (has_identity()) {
+      if (identity_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        identity_->clear();
+      }
+    }
+    if (has_channel_id()) {
+      if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
+    }
+    if (has_subscriber()) {
+      if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SendMessageNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.SendMessageNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_message;
+        break;
+      }
+
+      // required .bgs.protocol.channel.v1.Message message = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_message:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_message()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_required_privileges;
+        break;
+      }
+
+      // optional uint64 required_privileges = 3 [default = 0];
+      case 3: {
+        if (tag == 24) {
+         parse_required_privileges:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &required_privileges_)));
+          set_has_required_privileges();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_identity;
+        break;
+      }
+
+      // optional string identity = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_identity:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_identity()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->identity().data(), this->identity().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "identity");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_channel_id;
+        break;
+      }
+
+      // optional .bgs.protocol.channel.v1.ChannelId channel_id = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_channel_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_channel_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_subscriber;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.Identity subscriber = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_subscriber:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.SendMessageNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.SendMessageNotification)
+  return false;
+#undef DO_
+}
+
+void SendMessageNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.SendMessageNotification)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.channel.v1.Message message = 2;
+  if (has_message()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->message(), output);
+  }
+
+  // optional uint64 required_privileges = 3 [default = 0];
+  if (has_required_privileges()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->required_privileges(), output);
+  }
+
+  // optional string identity = 4;
+  if (has_identity()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->identity().data(), this->identity().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "identity");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->identity(), output);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 5;
+  if (has_channel_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->channel_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 6;
+  if (has_subscriber()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->subscriber(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.SendMessageNotification)
+}
+
+::google::protobuf::uint8* SendMessageNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.SendMessageNotification)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.channel.v1.Message message = 2;
+  if (has_message()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->message(), target);
+  }
+
+  // optional uint64 required_privileges = 3 [default = 0];
+  if (has_required_privileges()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->required_privileges(), target);
+  }
+
+  // optional string identity = 4;
+  if (has_identity()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->identity().data(), this->identity().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "identity");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->identity(), target);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 5;
+  if (has_channel_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->channel_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 6;
+  if (has_subscriber()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->subscriber(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.SendMessageNotification)
+  return target;
+}
+
+int SendMessageNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.channel.v1.Message message = 2;
+    if (has_message()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->message());
+    }
+
+    // optional uint64 required_privileges = 3 [default = 0];
+    if (has_required_privileges()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->required_privileges());
+    }
+
+    // optional string identity = 4;
+    if (has_identity()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->identity());
+    }
+
+    // optional .bgs.protocol.channel.v1.ChannelId channel_id = 5;
+    if (has_channel_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->channel_id());
+    }
+
+    // optional .bgs.protocol.account.v1.Identity subscriber = 6;
+    if (has_subscriber()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SendMessageNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SendMessageNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SendMessageNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SendMessageNotification::MergeFrom(const SendMessageNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_message()) {
+      mutable_message()->::bgs::protocol::channel::v1::Message::MergeFrom(from.message());
+    }
+    if (from.has_required_privileges()) {
+      set_required_privileges(from.required_privileges());
+    }
+    if (from.has_identity()) {
+      set_identity(from.identity());
+    }
+    if (from.has_channel_id()) {
+      mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id());
+    }
+    if (from.has_subscriber()) {
+      mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SendMessageNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SendMessageNotification::CopyFrom(const SendMessageNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SendMessageNotification::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_message()) {
+    if (!this->message().IsInitialized()) return false;
+  }
+  if (has_channel_id()) {
+    if (!this->channel_id().IsInitialized()) return false;
+  }
+  if (has_subscriber()) {
+    if (!this->subscriber().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SendMessageNotification::Swap(SendMessageNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(message_, other->message_);
+    std::swap(required_privileges_, other->required_privileges_);
+    std::swap(identity_, other->identity_);
+    std::swap(channel_id_, other->channel_id_);
+    std::swap(subscriber_, other->subscriber_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SendMessageNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SendMessageNotification_descriptor_;
+  metadata.reflection = SendMessageNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UpdateChannelStateNotification::kAgentIdFieldNumber;
+const int UpdateChannelStateNotification::kStateChangeFieldNumber;
+const int UpdateChannelStateNotification::kChannelIdFieldNumber;
+const int UpdateChannelStateNotification::kSubscriberFieldNumber;
+#endif  // !_MSC_VER
+
+UpdateChannelStateNotification::UpdateChannelStateNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.UpdateChannelStateNotification)
+}
+
+void UpdateChannelStateNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  state_change_ = const_cast< ::bgs::protocol::channel::v1::ChannelState*>(&::bgs::protocol::channel::v1::ChannelState::default_instance());
+  channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance());
+  subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
+}
+
+UpdateChannelStateNotification::UpdateChannelStateNotification(const UpdateChannelStateNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.UpdateChannelStateNotification)
+}
+
+void UpdateChannelStateNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  state_change_ = NULL;
+  channel_id_ = NULL;
+  subscriber_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UpdateChannelStateNotification::~UpdateChannelStateNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.UpdateChannelStateNotification)
+  SharedDtor();
+}
+
+void UpdateChannelStateNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete state_change_;
+    delete channel_id_;
+    delete subscriber_;
+  }
+}
+
+void UpdateChannelStateNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UpdateChannelStateNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UpdateChannelStateNotification_descriptor_;
+}
+
+const UpdateChannelStateNotification& UpdateChannelStateNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
+  return *default_instance_;
+}
+
+UpdateChannelStateNotification* UpdateChannelStateNotification::default_instance_ = NULL;
+
+UpdateChannelStateNotification* UpdateChannelStateNotification::New() const {
+  return new UpdateChannelStateNotification;
+}
+
+void UpdateChannelStateNotification::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_state_change()) {
+      if (state_change_ != NULL) state_change_->::bgs::protocol::channel::v1::ChannelState::Clear();
+    }
+    if (has_channel_id()) {
+      if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
+    }
+    if (has_subscriber()) {
+      if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UpdateChannelStateNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.UpdateChannelStateNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_state_change;
+        break;
+      }
+
+      // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_state_change:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_state_change()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_channel_id;
+        break;
+      }
+
+      // optional .bgs.protocol.channel.v1.ChannelId channel_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_channel_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_channel_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_subscriber;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.Identity subscriber = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_subscriber:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.UpdateChannelStateNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.UpdateChannelStateNotification)
+  return false;
+#undef DO_
+}
+
+void UpdateChannelStateNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.UpdateChannelStateNotification)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
+  if (has_state_change()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->state_change(), output);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 3;
+  if (has_channel_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->channel_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 4;
+  if (has_subscriber()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->subscriber(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.UpdateChannelStateNotification)
+}
+
+::google::protobuf::uint8* UpdateChannelStateNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.UpdateChannelStateNotification)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
+  if (has_state_change()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->state_change(), target);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 3;
+  if (has_channel_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->channel_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 4;
+  if (has_subscriber()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->subscriber(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.UpdateChannelStateNotification)
+  return target;
+}
+
+int UpdateChannelStateNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
+    if (has_state_change()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->state_change());
+    }
+
+    // optional .bgs.protocol.channel.v1.ChannelId channel_id = 3;
+    if (has_channel_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->channel_id());
+    }
+
+    // optional .bgs.protocol.account.v1.Identity subscriber = 4;
+    if (has_subscriber()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UpdateChannelStateNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UpdateChannelStateNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateChannelStateNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UpdateChannelStateNotification::MergeFrom(const UpdateChannelStateNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_state_change()) {
+      mutable_state_change()->::bgs::protocol::channel::v1::ChannelState::MergeFrom(from.state_change());
+    }
+    if (from.has_channel_id()) {
+      mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id());
+    }
+    if (from.has_subscriber()) {
+      mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UpdateChannelStateNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UpdateChannelStateNotification::CopyFrom(const UpdateChannelStateNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UpdateChannelStateNotification::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_state_change()) {
+    if (!this->state_change().IsInitialized()) return false;
+  }
+  if (has_channel_id()) {
+    if (!this->channel_id().IsInitialized()) return false;
+  }
+  if (has_subscriber()) {
+    if (!this->subscriber().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UpdateChannelStateNotification::Swap(UpdateChannelStateNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(state_change_, other->state_change_);
+    std::swap(channel_id_, other->channel_id_);
+    std::swap(subscriber_, other->subscriber_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UpdateChannelStateNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UpdateChannelStateNotification_descriptor_;
+  metadata.reflection = UpdateChannelStateNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UpdateMemberStateNotification::kAgentIdFieldNumber;
+const int UpdateMemberStateNotification::kStateChangeFieldNumber;
+const int UpdateMemberStateNotification::kRemovedRoleFieldNumber;
+const int UpdateMemberStateNotification::kChannelIdFieldNumber;
+const int UpdateMemberStateNotification::kSubscriberFieldNumber;
+#endif  // !_MSC_VER
+
+UpdateMemberStateNotification::UpdateMemberStateNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.UpdateMemberStateNotification)
+}
+
+void UpdateMemberStateNotification::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  channel_id_ = const_cast< ::bgs::protocol::channel::v1::ChannelId*>(&::bgs::protocol::channel::v1::ChannelId::default_instance());
+  subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
+}
+
+UpdateMemberStateNotification::UpdateMemberStateNotification(const UpdateMemberStateNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.UpdateMemberStateNotification)
+}
+
+void UpdateMemberStateNotification::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  channel_id_ = NULL;
+  subscriber_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UpdateMemberStateNotification::~UpdateMemberStateNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.UpdateMemberStateNotification)
+  SharedDtor();
+}
+
+void UpdateMemberStateNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete channel_id_;
+    delete subscriber_;
+  }
+}
+
+void UpdateMemberStateNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UpdateMemberStateNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UpdateMemberStateNotification_descriptor_;
+}
+
+const UpdateMemberStateNotification& UpdateMemberStateNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5fservice_2eproto();
+  return *default_instance_;
+}
+
+UpdateMemberStateNotification* UpdateMemberStateNotification::default_instance_ = NULL;
+
+UpdateMemberStateNotification* UpdateMemberStateNotification::New() const {
+  return new UpdateMemberStateNotification;
+}
+
+void UpdateMemberStateNotification::Clear() {
+  if (_has_bits_[0 / 32] & 25) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_channel_id()) {
+      if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
+    }
+    if (has_subscriber()) {
+      if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
+    }
+  }
+  state_change_.Clear();
+  removed_role_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UpdateMemberStateNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.UpdateMemberStateNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_state_change;
+        break;
+      }
+
+      // repeated .bgs.protocol.channel.v1.Member state_change = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_state_change:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_state_change()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_state_change;
+        if (input->ExpectTag(26)) goto parse_removed_role;
+        break;
+      }
+
+      // repeated uint32 removed_role = 3 [packed = true];
+      case 3: {
+        if (tag == 26) {
+         parse_removed_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_removed_role())));
+        } else if (tag == 24) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 26, input, this->mutable_removed_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_channel_id;
+        break;
+      }
+
+      // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_channel_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_channel_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_subscriber;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_subscriber:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.UpdateMemberStateNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.UpdateMemberStateNotification)
+  return false;
+#undef DO_
+}
+
+void UpdateMemberStateNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.UpdateMemberStateNotification)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // repeated .bgs.protocol.channel.v1.Member state_change = 2;
+  for (int i = 0; i < this->state_change_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->state_change(i), output);
+  }
+
+  // repeated uint32 removed_role = 3 [packed = true];
+  if (this->removed_role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_removed_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->removed_role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->removed_role(i), output);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+  if (has_channel_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->channel_id(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+  if (has_subscriber()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->subscriber(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.UpdateMemberStateNotification)
+}
+
+::google::protobuf::uint8* UpdateMemberStateNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.UpdateMemberStateNotification)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // repeated .bgs.protocol.channel.v1.Member state_change = 2;
+  for (int i = 0; i < this->state_change_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->state_change(i), target);
+  }
+
+  // repeated uint32 removed_role = 3 [packed = true];
+  if (this->removed_role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      3,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _removed_role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->removed_role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->removed_role(i), target);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+  if (has_channel_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->channel_id(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+  if (has_subscriber()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->subscriber(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.UpdateMemberStateNotification)
+  return target;
+}
+
+int UpdateMemberStateNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+    if (has_channel_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->channel_id());
+    }
+
+    // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+    if (has_subscriber()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber());
+    }
+
+  }
+  // repeated .bgs.protocol.channel.v1.Member state_change = 2;
+  total_size += 1 * this->state_change_size();
+  for (int i = 0; i < this->state_change_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->state_change(i));
+  }
+
+  // repeated uint32 removed_role = 3 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->removed_role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->removed_role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _removed_role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UpdateMemberStateNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UpdateMemberStateNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateMemberStateNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UpdateMemberStateNotification::MergeFrom(const UpdateMemberStateNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  state_change_.MergeFrom(from.state_change_);
+  removed_role_.MergeFrom(from.removed_role_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_channel_id()) {
+      mutable_channel_id()->::bgs::protocol::channel::v1::ChannelId::MergeFrom(from.channel_id());
+    }
+    if (from.has_subscriber()) {
+      mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UpdateMemberStateNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UpdateMemberStateNotification::CopyFrom(const UpdateMemberStateNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UpdateMemberStateNotification::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->state_change())) return false;
+  if (has_channel_id()) {
+    if (!this->channel_id().IsInitialized()) return false;
+  }
+  if (has_subscriber()) {
+    if (!this->subscriber().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UpdateMemberStateNotification::Swap(UpdateMemberStateNotification* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    state_change_.Swap(&other->state_change_);
+    removed_role_.Swap(&other->removed_role_);
+    std::swap(channel_id_, other->channel_id_);
+    std::swap(subscriber_, other->subscriber_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UpdateMemberStateNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UpdateMemberStateNotification_descriptor_;
+  metadata.reflection = UpdateMemberStateNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* ChannelService::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChannelService_descriptor_;
+}
+
+void ChannelService::AddMember(::bgs::protocol::channel::v1::AddMemberRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.AddMember(bgs.protocol.channel.v1.AddMemberRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ChannelService::RemoveMember(::bgs::protocol::channel::v1::RemoveMemberRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.RemoveMember(bgs.protocol.channel.v1.RemoveMemberRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 2, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ChannelService::SendMessage(::bgs::protocol::channel::v1::SendMessageRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.SendMessage(bgs.protocol.channel.v1.SendMessageRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 3, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ChannelService::UpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.UpdateChannelState(bgs.protocol.channel.v1.UpdateChannelStateRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 4, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ChannelService::UpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.UpdateMemberState(bgs.protocol.channel.v1.UpdateMemberStateRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 5, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ChannelService::Dissolve(::bgs::protocol::channel::v1::DissolveRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.Dissolve(bgs.protocol.channel.v1.DissolveRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 6, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ChannelService::SetRoles(::bgs::protocol::channel::v1::SetRolesRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.SetRoles(bgs.protocol.channel.v1.SetRolesRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 7, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ChannelService::UnsubscribeMember(::bgs::protocol::channel::v1::UnsubscribeMemberRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelService.UnsubscribeMember(bgs.protocol.channel.v1.UnsubscribeMemberRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 8, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ChannelService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::channel::v1::AddMemberRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.AddMember server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleAddMember(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.AddMember(bgs.protocol.channel.v1.AddMemberRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 1, token, &response);
+      else
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    case 2: {
+      ::bgs::protocol::channel::v1::RemoveMemberRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.RemoveMember server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleRemoveMember(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.RemoveMember(bgs.protocol.channel.v1.RemoveMemberRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 2, token, &response);
+      else
+        SendResponse(service_hash_, 2, token, status);
+      break;
+    }
+    case 3: {
+      ::bgs::protocol::channel::v1::SendMessageRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.SendMessage server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleSendMessage(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.SendMessage(bgs.protocol.channel.v1.SendMessageRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 3, token, &response);
+      else
+        SendResponse(service_hash_, 3, token, status);
+      break;
+    }
+    case 4: {
+      ::bgs::protocol::channel::v1::UpdateChannelStateRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.UpdateChannelState server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleUpdateChannelState(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.UpdateChannelState(bgs.protocol.channel.v1.UpdateChannelStateRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 4, token, &response);
+      else
+        SendResponse(service_hash_, 4, token, status);
+      break;
+    }
+    case 5: {
+      ::bgs::protocol::channel::v1::UpdateMemberStateRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.UpdateMemberState server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleUpdateMemberState(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.UpdateMemberState(bgs.protocol.channel.v1.UpdateMemberStateRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 5, token, &response);
+      else
+        SendResponse(service_hash_, 5, token, status);
+      break;
+    }
+    case 6: {
+      ::bgs::protocol::channel::v1::DissolveRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.Dissolve server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleDissolve(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.Dissolve(bgs.protocol.channel.v1.DissolveRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 6, token, &response);
+      else
+        SendResponse(service_hash_, 6, token, status);
+      break;
+    }
+    case 7: {
+      ::bgs::protocol::channel::v1::SetRolesRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.SetRoles server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleSetRoles(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.SetRoles(bgs.protocol.channel.v1.SetRolesRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 7, token, &response);
+      else
+        SendResponse(service_hash_, 7, token, status);
+      break;
+    }
+    case 8: {
+      ::bgs::protocol::channel::v1::UnsubscribeMemberRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelService.UnsubscribeMember server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 8, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleUnsubscribeMember(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelService.UnsubscribeMember(bgs.protocol.channel.v1.UnsubscribeMemberRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 8, token, &response);
+      else
+        SendResponse(service_hash_, 8, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 ChannelService::HandleAddMember(::bgs::protocol::channel::v1::AddMemberRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.AddMember({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChannelService::HandleRemoveMember(::bgs::protocol::channel::v1::RemoveMemberRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.RemoveMember({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChannelService::HandleSendMessage(::bgs::protocol::channel::v1::SendMessageRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.SendMessage({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChannelService::HandleUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.UpdateChannelState({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChannelService::HandleUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.UpdateMemberState({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChannelService::HandleDissolve(::bgs::protocol::channel::v1::DissolveRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.Dissolve({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChannelService::HandleSetRoles(::bgs::protocol::channel::v1::SetRolesRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.SetRoles({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChannelService::HandleUnsubscribeMember(::bgs::protocol::channel::v1::UnsubscribeMemberRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelService.UnsubscribeMember({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* ChannelListener::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChannelListener_descriptor_;
+}
+
+void ChannelListener::OnJoin(::bgs::protocol::channel::v1::JoinNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnJoin(bgs.protocol.channel.v1.JoinNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request);
+}
+
+void ChannelListener::OnMemberAdded(::bgs::protocol::channel::v1::MemberAddedNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnMemberAdded(bgs.protocol.channel.v1.MemberAddedNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 2, request);
+}
+
+void ChannelListener::OnLeave(::bgs::protocol::channel::v1::LeaveNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnLeave(bgs.protocol.channel.v1.LeaveNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 3, request);
+}
+
+void ChannelListener::OnMemberRemoved(::bgs::protocol::channel::v1::MemberRemovedNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnMemberRemoved(bgs.protocol.channel.v1.MemberRemovedNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 4, request);
+}
+
+void ChannelListener::OnSendMessage(::bgs::protocol::channel::v1::SendMessageNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnSendMessage(bgs.protocol.channel.v1.SendMessageNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 5, request);
+}
+
+void ChannelListener::OnUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnUpdateChannelState(bgs.protocol.channel.v1.UpdateChannelStateNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 6, request);
+}
+
+void ChannelListener::OnUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ChannelListener.OnUpdateMemberState(bgs.protocol.channel.v1.UpdateMemberStateNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 7, request);
+}
+
+void ChannelListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::channel::v1::JoinNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnJoin server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnJoin(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnJoin(bgs.protocol.channel.v1.JoinNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    case 2: {
+      ::bgs::protocol::channel::v1::MemberAddedNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnMemberAdded server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnMemberAdded(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnMemberAdded(bgs.protocol.channel.v1.MemberAddedNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 2, token, status);
+      break;
+    }
+    case 3: {
+      ::bgs::protocol::channel::v1::LeaveNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnLeave server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnLeave(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnLeave(bgs.protocol.channel.v1.LeaveNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 3, token, status);
+      break;
+    }
+    case 4: {
+      ::bgs::protocol::channel::v1::MemberRemovedNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnMemberRemoved server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnMemberRemoved(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnMemberRemoved(bgs.protocol.channel.v1.MemberRemovedNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 4, token, status);
+      break;
+    }
+    case 5: {
+      ::bgs::protocol::channel::v1::SendMessageNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnSendMessage server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnSendMessage(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnSendMessage(bgs.protocol.channel.v1.SendMessageNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 5, token, status);
+      break;
+    }
+    case 6: {
+      ::bgs::protocol::channel::v1::UpdateChannelStateNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnUpdateChannelState server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnUpdateChannelState(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnUpdateChannelState(bgs.protocol.channel.v1.UpdateChannelStateNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 6, token, status);
+      break;
+    }
+    case 7: {
+      ::bgs::protocol::channel::v1::UpdateMemberStateNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ChannelListener.OnUpdateMemberState server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnUpdateMemberState(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ChannelListener.OnUpdateMemberState(bgs.protocol.channel.v1.UpdateMemberStateNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 7, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 ChannelListener::HandleOnJoin(::bgs::protocol::channel::v1::JoinNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnJoin({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChannelListener::HandleOnMemberAdded(::bgs::protocol::channel::v1::MemberAddedNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnMemberAdded({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChannelListener::HandleOnLeave(::bgs::protocol::channel::v1::LeaveNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnLeave({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChannelListener::HandleOnMemberRemoved(::bgs::protocol::channel::v1::MemberRemovedNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnMemberRemoved({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChannelListener::HandleOnSendMessage(::bgs::protocol::channel::v1::SendMessageNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnSendMessage({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChannelListener::HandleOnUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnUpdateChannelState({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ChannelListener::HandleOnUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ChannelListener.OnUpdateMemberState({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace channel
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/channel_service.pb.h b/src/server/proto/Client/channel_service.pb.h
new file mode 100644
index 00000000000..9f7ed094e63
--- /dev/null
+++ b/src/server/proto/Client/channel_service.pb.h
@@ -0,0 +1,4053 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: channel_service.proto
+
+#ifndef PROTOBUF_channel_5fservice_2eproto__INCLUDED
+#define PROTOBUF_channel_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 "entity_types.pb.h"
+#include "channel_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 channel {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto();
+void protobuf_AssignDesc_channel_5fservice_2eproto();
+void protobuf_ShutdownFile_channel_5fservice_2eproto();
+
+class AddMemberRequest;
+class RemoveMemberRequest;
+class UnsubscribeMemberRequest;
+class SendMessageRequest;
+class UpdateChannelStateRequest;
+class UpdateMemberStateRequest;
+class DissolveRequest;
+class SetRolesRequest;
+class JoinNotification;
+class MemberAddedNotification;
+class LeaveNotification;
+class MemberRemovedNotification;
+class SendMessageNotification;
+class UpdateChannelStateNotification;
+class UpdateMemberStateNotification;
+
+// ===================================================================
+
+class TC_SHARED_API AddMemberRequest : public ::google::protobuf::Message {
+ public:
+  AddMemberRequest();
+  virtual ~AddMemberRequest();
+
+  AddMemberRequest(const AddMemberRequest& from);
+
+  inline AddMemberRequest& operator=(const AddMemberRequest& 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 AddMemberRequest& default_instance();
+
+  void Swap(AddMemberRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  AddMemberRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AddMemberRequest& from);
+  void MergeFrom(const AddMemberRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.Identity member_identity = 2;
+  inline bool has_member_identity() const;
+  inline void clear_member_identity();
+  static const int kMemberIdentityFieldNumber = 2;
+  inline const ::bgs::protocol::Identity& member_identity() const;
+  inline ::bgs::protocol::Identity* mutable_member_identity();
+  inline ::bgs::protocol::Identity* release_member_identity();
+  inline void set_allocated_member_identity(::bgs::protocol::Identity* member_identity);
+
+  // required .bgs.protocol.channel.v1.MemberState member_state = 3;
+  inline bool has_member_state() const;
+  inline void clear_member_state();
+  static const int kMemberStateFieldNumber = 3;
+  inline const ::bgs::protocol::channel::v1::MemberState& member_state() const;
+  inline ::bgs::protocol::channel::v1::MemberState* mutable_member_state();
+  inline ::bgs::protocol::channel::v1::MemberState* release_member_state();
+  inline void set_allocated_member_state(::bgs::protocol::channel::v1::MemberState* member_state);
+
+  // required uint64 object_id = 4;
+  inline bool has_object_id() const;
+  inline void clear_object_id();
+  static const int kObjectIdFieldNumber = 4;
+  inline ::google::protobuf::uint64 object_id() const;
+  inline void set_object_id(::google::protobuf::uint64 value);
+
+  // optional bool subscribe = 5 [default = true];
+  inline bool has_subscribe() const;
+  inline void clear_subscribe();
+  static const int kSubscribeFieldNumber = 5;
+  inline bool subscribe() const;
+  inline void set_subscribe(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.AddMemberRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_member_identity();
+  inline void clear_has_member_identity();
+  inline void set_has_member_state();
+  inline void clear_has_member_state();
+  inline void set_has_object_id();
+  inline void clear_has_object_id();
+  inline void set_has_subscribe();
+  inline void clear_has_subscribe();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::Identity* member_identity_;
+  ::bgs::protocol::channel::v1::MemberState* member_state_;
+  ::google::protobuf::uint64 object_id_;
+  bool subscribe_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto();
+  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static AddMemberRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API RemoveMemberRequest : public ::google::protobuf::Message {
+ public:
+  RemoveMemberRequest();
+  virtual ~RemoveMemberRequest();
+
+  RemoveMemberRequest(const RemoveMemberRequest& from);
+
+  inline RemoveMemberRequest& operator=(const RemoveMemberRequest& 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 RemoveMemberRequest& default_instance();
+
+  void Swap(RemoveMemberRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  RemoveMemberRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RemoveMemberRequest& from);
+  void MergeFrom(const RemoveMemberRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.EntityId member_id = 2;
+  inline bool has_member_id() const;
+  inline void clear_member_id();
+  static const int kMemberIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& member_id() const;
+  inline ::bgs::protocol::EntityId* mutable_member_id();
+  inline ::bgs::protocol::EntityId* release_member_id();
+  inline void set_allocated_member_id(::bgs::protocol::EntityId* member_id);
+
+  // optional uint32 reason = 3;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 3;
+  inline ::google::protobuf::uint32 reason() const;
+  inline void set_reason(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.RemoveMemberRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_member_id();
+  inline void clear_has_member_id();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::EntityId* member_id_;
+  ::google::protobuf::uint32 reason_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto();
+  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static RemoveMemberRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API UnsubscribeMemberRequest : public ::google::protobuf::Message {
+ public:
+  UnsubscribeMemberRequest();
+  virtual ~UnsubscribeMemberRequest();
+
+  UnsubscribeMemberRequest(const UnsubscribeMemberRequest& from);
+
+  inline UnsubscribeMemberRequest& operator=(const UnsubscribeMemberRequest& 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 UnsubscribeMemberRequest& default_instance();
+
+  void Swap(UnsubscribeMemberRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UnsubscribeMemberRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UnsubscribeMemberRequest& from);
+  void MergeFrom(const UnsubscribeMemberRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.EntityId member_id = 2;
+  inline bool has_member_id() const;
+  inline void clear_member_id();
+  static const int kMemberIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& member_id() const;
+  inline ::bgs::protocol::EntityId* mutable_member_id();
+  inline ::bgs::protocol::EntityId* release_member_id();
+  inline void set_allocated_member_id(::bgs::protocol::EntityId* member_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.UnsubscribeMemberRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_member_id();
+  inline void clear_has_member_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::EntityId* member_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto();
+  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static UnsubscribeMemberRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API SendMessageRequest : public ::google::protobuf::Message {
+ public:
+  SendMessageRequest();
+  virtual ~SendMessageRequest();
+
+  SendMessageRequest(const SendMessageRequest& from);
+
+  inline SendMessageRequest& operator=(const SendMessageRequest& 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 SendMessageRequest& default_instance();
+
+  void Swap(SendMessageRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SendMessageRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SendMessageRequest& from);
+  void MergeFrom(const SendMessageRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.channel.v1.Message message = 2;
+  inline bool has_message() const;
+  inline void clear_message();
+  static const int kMessageFieldNumber = 2;
+  inline const ::bgs::protocol::channel::v1::Message& message() const;
+  inline ::bgs::protocol::channel::v1::Message* mutable_message();
+  inline ::bgs::protocol::channel::v1::Message* release_message();
+  inline void set_allocated_message(::bgs::protocol::channel::v1::Message* message);
+
+  // optional uint64 required_privileges = 3 [default = 0];
+  inline bool has_required_privileges() const;
+  inline void clear_required_privileges();
+  static const int kRequiredPrivilegesFieldNumber = 3;
+  inline ::google::protobuf::uint64 required_privileges() const;
+  inline void set_required_privileges(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.SendMessageRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_message();
+  inline void clear_has_message();
+  inline void set_has_required_privileges();
+  inline void clear_has_required_privileges();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::channel::v1::Message* message_;
+  ::google::protobuf::uint64 required_privileges_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto();
+  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SendMessageRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API UpdateChannelStateRequest : public ::google::protobuf::Message {
+ public:
+  UpdateChannelStateRequest();
+  virtual ~UpdateChannelStateRequest();
+
+  UpdateChannelStateRequest(const UpdateChannelStateRequest& from);
+
+  inline UpdateChannelStateRequest& operator=(const UpdateChannelStateRequest& 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 UpdateChannelStateRequest& default_instance();
+
+  void Swap(UpdateChannelStateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UpdateChannelStateRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UpdateChannelStateRequest& from);
+  void MergeFrom(const UpdateChannelStateRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
+  inline bool has_state_change() const;
+  inline void clear_state_change();
+  static const int kStateChangeFieldNumber = 2;
+  inline const ::bgs::protocol::channel::v1::ChannelState& state_change() const;
+  inline ::bgs::protocol::channel::v1::ChannelState* mutable_state_change();
+  inline ::bgs::protocol::channel::v1::ChannelState* release_state_change();
+  inline void set_allocated_state_change(::bgs::protocol::channel::v1::ChannelState* state_change);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.UpdateChannelStateRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_state_change();
+  inline void clear_has_state_change();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::channel::v1::ChannelState* state_change_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto();
+  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static UpdateChannelStateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API UpdateMemberStateRequest : public ::google::protobuf::Message {
+ public:
+  UpdateMemberStateRequest();
+  virtual ~UpdateMemberStateRequest();
+
+  UpdateMemberStateRequest(const UpdateMemberStateRequest& from);
+
+  inline UpdateMemberStateRequest& operator=(const UpdateMemberStateRequest& 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 UpdateMemberStateRequest& default_instance();
+
+  void Swap(UpdateMemberStateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UpdateMemberStateRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UpdateMemberStateRequest& from);
+  void MergeFrom(const UpdateMemberStateRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // repeated .bgs.protocol.channel.v1.Member state_change = 2;
+  inline int state_change_size() const;
+  inline void clear_state_change();
+  static const int kStateChangeFieldNumber = 2;
+  inline const ::bgs::protocol::channel::v1::Member& state_change(int index) const;
+  inline ::bgs::protocol::channel::v1::Member* mutable_state_change(int index);
+  inline ::bgs::protocol::channel::v1::Member* add_state_change();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >&
+      state_change() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >*
+      mutable_state_change();
+
+  // repeated uint32 removed_role = 3 [packed = true];
+  inline int removed_role_size() const;
+  inline void clear_removed_role();
+  static const int kRemovedRoleFieldNumber = 3;
+  inline ::google::protobuf::uint32 removed_role(int index) const;
+  inline void set_removed_role(int index, ::google::protobuf::uint32 value);
+  inline void add_removed_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      removed_role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_removed_role();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.UpdateMemberStateRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member > state_change_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > removed_role_;
+  mutable int _removed_role_cached_byte_size_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto();
+  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static UpdateMemberStateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API DissolveRequest : public ::google::protobuf::Message {
+ public:
+  DissolveRequest();
+  virtual ~DissolveRequest();
+
+  DissolveRequest(const DissolveRequest& from);
+
+  inline DissolveRequest& operator=(const DissolveRequest& 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 DissolveRequest& default_instance();
+
+  void Swap(DissolveRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  DissolveRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const DissolveRequest& from);
+  void MergeFrom(const DissolveRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // optional uint32 reason = 2;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 2;
+  inline ::google::protobuf::uint32 reason() const;
+  inline void set_reason(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.DissolveRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::uint32 reason_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto();
+  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static DissolveRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API SetRolesRequest : public ::google::protobuf::Message {
+ public:
+  SetRolesRequest();
+  virtual ~SetRolesRequest();
+
+  SetRolesRequest(const SetRolesRequest& from);
+
+  inline SetRolesRequest& operator=(const SetRolesRequest& 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 SetRolesRequest& default_instance();
+
+  void Swap(SetRolesRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SetRolesRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SetRolesRequest& from);
+  void MergeFrom(const SetRolesRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // repeated uint32 role = 2 [packed = true];
+  inline int role_size() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 2;
+  inline ::google::protobuf::uint32 role(int index) const;
+  inline void set_role(int index, ::google::protobuf::uint32 value);
+  inline void add_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_role();
+
+  // repeated .bgs.protocol.EntityId member_id = 3;
+  inline int member_id_size() const;
+  inline void clear_member_id();
+  static const int kMemberIdFieldNumber = 3;
+  inline const ::bgs::protocol::EntityId& member_id(int index) const;
+  inline ::bgs::protocol::EntityId* mutable_member_id(int index);
+  inline ::bgs::protocol::EntityId* add_member_id();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >&
+      member_id() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >*
+      mutable_member_id();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.SetRolesRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
+  mutable int _role_cached_byte_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId > member_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto();
+  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SetRolesRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API JoinNotification : public ::google::protobuf::Message {
+ public:
+  JoinNotification();
+  virtual ~JoinNotification();
+
+  JoinNotification(const JoinNotification& from);
+
+  inline JoinNotification& operator=(const JoinNotification& 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 JoinNotification& default_instance();
+
+  void Swap(JoinNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  JoinNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const JoinNotification& from);
+  void MergeFrom(const JoinNotification& 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.channel.v1.Member self = 1;
+  inline bool has_self() const;
+  inline void clear_self();
+  static const int kSelfFieldNumber = 1;
+  inline const ::bgs::protocol::channel::v1::Member& self() const;
+  inline ::bgs::protocol::channel::v1::Member* mutable_self();
+  inline ::bgs::protocol::channel::v1::Member* release_self();
+  inline void set_allocated_self(::bgs::protocol::channel::v1::Member* self);
+
+  // repeated .bgs.protocol.channel.v1.Member member = 2;
+  inline int member_size() const;
+  inline void clear_member();
+  static const int kMemberFieldNumber = 2;
+  inline const ::bgs::protocol::channel::v1::Member& member(int index) const;
+  inline ::bgs::protocol::channel::v1::Member* mutable_member(int index);
+  inline ::bgs::protocol::channel::v1::Member* add_member();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >&
+      member() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >*
+      mutable_member();
+
+  // required .bgs.protocol.channel.v1.ChannelState channel_state = 3;
+  inline bool has_channel_state() const;
+  inline void clear_channel_state();
+  static const int kChannelStateFieldNumber = 3;
+  inline const ::bgs::protocol::channel::v1::ChannelState& channel_state() const;
+  inline ::bgs::protocol::channel::v1::ChannelState* mutable_channel_state();
+  inline ::bgs::protocol::channel::v1::ChannelState* release_channel_state();
+  inline void set_allocated_channel_state(::bgs::protocol::channel::v1::ChannelState* channel_state);
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+  inline bool has_channel_id() const;
+  inline void clear_channel_id();
+  static const int kChannelIdFieldNumber = 4;
+  inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const;
+  inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id();
+  inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id();
+  inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id);
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+  inline bool has_subscriber() const;
+  inline void clear_subscriber();
+  static const int kSubscriberFieldNumber = 5;
+  inline const ::bgs::protocol::account::v1::Identity& subscriber() const;
+  inline ::bgs::protocol::account::v1::Identity* mutable_subscriber();
+  inline ::bgs::protocol::account::v1::Identity* release_subscriber();
+  inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.JoinNotification)
+ private:
+  inline void set_has_self();
+  inline void clear_has_self();
+  inline void set_has_channel_state();
+  inline void clear_has_channel_state();
+  inline void set_has_channel_id();
+  inline void clear_has_channel_id();
+  inline void set_has_subscriber();
+  inline void clear_has_subscriber();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::channel::v1::Member* self_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member > member_;
+  ::bgs::protocol::channel::v1::ChannelState* channel_state_;
+  ::bgs::protocol::channel::v1::ChannelId* channel_id_;
+  ::bgs::protocol::account::v1::Identity* subscriber_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto();
+  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static JoinNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API MemberAddedNotification : public ::google::protobuf::Message {
+ public:
+  MemberAddedNotification();
+  virtual ~MemberAddedNotification();
+
+  MemberAddedNotification(const MemberAddedNotification& from);
+
+  inline MemberAddedNotification& operator=(const MemberAddedNotification& 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 MemberAddedNotification& default_instance();
+
+  void Swap(MemberAddedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  MemberAddedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MemberAddedNotification& from);
+  void MergeFrom(const MemberAddedNotification& 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.channel.v1.Member member = 1;
+  inline bool has_member() const;
+  inline void clear_member();
+  static const int kMemberFieldNumber = 1;
+  inline const ::bgs::protocol::channel::v1::Member& member() const;
+  inline ::bgs::protocol::channel::v1::Member* mutable_member();
+  inline ::bgs::protocol::channel::v1::Member* release_member();
+  inline void set_allocated_member(::bgs::protocol::channel::v1::Member* member);
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 2;
+  inline bool has_channel_id() const;
+  inline void clear_channel_id();
+  static const int kChannelIdFieldNumber = 2;
+  inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const;
+  inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id();
+  inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id();
+  inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id);
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 3;
+  inline bool has_subscriber() const;
+  inline void clear_subscriber();
+  static const int kSubscriberFieldNumber = 3;
+  inline const ::bgs::protocol::account::v1::Identity& subscriber() const;
+  inline ::bgs::protocol::account::v1::Identity* mutable_subscriber();
+  inline ::bgs::protocol::account::v1::Identity* release_subscriber();
+  inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.MemberAddedNotification)
+ private:
+  inline void set_has_member();
+  inline void clear_has_member();
+  inline void set_has_channel_id();
+  inline void clear_has_channel_id();
+  inline void set_has_subscriber();
+  inline void clear_has_subscriber();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::channel::v1::Member* member_;
+  ::bgs::protocol::channel::v1::ChannelId* channel_id_;
+  ::bgs::protocol::account::v1::Identity* subscriber_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto();
+  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static MemberAddedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API LeaveNotification : public ::google::protobuf::Message {
+ public:
+  LeaveNotification();
+  virtual ~LeaveNotification();
+
+  LeaveNotification(const LeaveNotification& from);
+
+  inline LeaveNotification& operator=(const LeaveNotification& 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 LeaveNotification& default_instance();
+
+  void Swap(LeaveNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  LeaveNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const LeaveNotification& from);
+  void MergeFrom(const LeaveNotification& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.EntityId member_id = 2;
+  inline bool has_member_id() const;
+  inline void clear_member_id();
+  static const int kMemberIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& member_id() const;
+  inline ::bgs::protocol::EntityId* mutable_member_id();
+  inline ::bgs::protocol::EntityId* release_member_id();
+  inline void set_allocated_member_id(::bgs::protocol::EntityId* member_id);
+
+  // optional uint32 reason = 3;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 3;
+  inline ::google::protobuf::uint32 reason() const;
+  inline void set_reason(::google::protobuf::uint32 value);
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+  inline bool has_channel_id() const;
+  inline void clear_channel_id();
+  static const int kChannelIdFieldNumber = 4;
+  inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const;
+  inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id();
+  inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id();
+  inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id);
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+  inline bool has_subscriber() const;
+  inline void clear_subscriber();
+  static const int kSubscriberFieldNumber = 5;
+  inline const ::bgs::protocol::account::v1::Identity& subscriber() const;
+  inline ::bgs::protocol::account::v1::Identity* mutable_subscriber();
+  inline ::bgs::protocol::account::v1::Identity* release_subscriber();
+  inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.LeaveNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_member_id();
+  inline void clear_has_member_id();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+  inline void set_has_channel_id();
+  inline void clear_has_channel_id();
+  inline void set_has_subscriber();
+  inline void clear_has_subscriber();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::EntityId* member_id_;
+  ::bgs::protocol::channel::v1::ChannelId* channel_id_;
+  ::bgs::protocol::account::v1::Identity* subscriber_;
+  ::google::protobuf::uint32 reason_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto();
+  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static LeaveNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API MemberRemovedNotification : public ::google::protobuf::Message {
+ public:
+  MemberRemovedNotification();
+  virtual ~MemberRemovedNotification();
+
+  MemberRemovedNotification(const MemberRemovedNotification& from);
+
+  inline MemberRemovedNotification& operator=(const MemberRemovedNotification& 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 MemberRemovedNotification& default_instance();
+
+  void Swap(MemberRemovedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  MemberRemovedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MemberRemovedNotification& from);
+  void MergeFrom(const MemberRemovedNotification& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.EntityId member_id = 2;
+  inline bool has_member_id() const;
+  inline void clear_member_id();
+  static const int kMemberIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& member_id() const;
+  inline ::bgs::protocol::EntityId* mutable_member_id();
+  inline ::bgs::protocol::EntityId* release_member_id();
+  inline void set_allocated_member_id(::bgs::protocol::EntityId* member_id);
+
+  // optional uint32 reason = 3;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 3;
+  inline ::google::protobuf::uint32 reason() const;
+  inline void set_reason(::google::protobuf::uint32 value);
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+  inline bool has_channel_id() const;
+  inline void clear_channel_id();
+  static const int kChannelIdFieldNumber = 4;
+  inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const;
+  inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id();
+  inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id();
+  inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id);
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+  inline bool has_subscriber() const;
+  inline void clear_subscriber();
+  static const int kSubscriberFieldNumber = 5;
+  inline const ::bgs::protocol::account::v1::Identity& subscriber() const;
+  inline ::bgs::protocol::account::v1::Identity* mutable_subscriber();
+  inline ::bgs::protocol::account::v1::Identity* release_subscriber();
+  inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.MemberRemovedNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_member_id();
+  inline void clear_has_member_id();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+  inline void set_has_channel_id();
+  inline void clear_has_channel_id();
+  inline void set_has_subscriber();
+  inline void clear_has_subscriber();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::EntityId* member_id_;
+  ::bgs::protocol::channel::v1::ChannelId* channel_id_;
+  ::bgs::protocol::account::v1::Identity* subscriber_;
+  ::google::protobuf::uint32 reason_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto();
+  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static MemberRemovedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API SendMessageNotification : public ::google::protobuf::Message {
+ public:
+  SendMessageNotification();
+  virtual ~SendMessageNotification();
+
+  SendMessageNotification(const SendMessageNotification& from);
+
+  inline SendMessageNotification& operator=(const SendMessageNotification& 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 SendMessageNotification& default_instance();
+
+  void Swap(SendMessageNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  SendMessageNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SendMessageNotification& from);
+  void MergeFrom(const SendMessageNotification& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.channel.v1.Message message = 2;
+  inline bool has_message() const;
+  inline void clear_message();
+  static const int kMessageFieldNumber = 2;
+  inline const ::bgs::protocol::channel::v1::Message& message() const;
+  inline ::bgs::protocol::channel::v1::Message* mutable_message();
+  inline ::bgs::protocol::channel::v1::Message* release_message();
+  inline void set_allocated_message(::bgs::protocol::channel::v1::Message* message);
+
+  // optional uint64 required_privileges = 3 [default = 0];
+  inline bool has_required_privileges() const;
+  inline void clear_required_privileges();
+  static const int kRequiredPrivilegesFieldNumber = 3;
+  inline ::google::protobuf::uint64 required_privileges() const;
+  inline void set_required_privileges(::google::protobuf::uint64 value);
+
+  // optional string identity = 4;
+  inline bool has_identity() const;
+  inline void clear_identity();
+  static const int kIdentityFieldNumber = 4;
+  inline const ::std::string& identity() const;
+  inline void set_identity(const ::std::string& value);
+  inline void set_identity(const char* value);
+  inline void set_identity(const char* value, size_t size);
+  inline ::std::string* mutable_identity();
+  inline ::std::string* release_identity();
+  inline void set_allocated_identity(::std::string* identity);
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 5;
+  inline bool has_channel_id() const;
+  inline void clear_channel_id();
+  static const int kChannelIdFieldNumber = 5;
+  inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const;
+  inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id();
+  inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id();
+  inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id);
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 6;
+  inline bool has_subscriber() const;
+  inline void clear_subscriber();
+  static const int kSubscriberFieldNumber = 6;
+  inline const ::bgs::protocol::account::v1::Identity& subscriber() const;
+  inline ::bgs::protocol::account::v1::Identity* mutable_subscriber();
+  inline ::bgs::protocol::account::v1::Identity* release_subscriber();
+  inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.SendMessageNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_message();
+  inline void clear_has_message();
+  inline void set_has_required_privileges();
+  inline void clear_has_required_privileges();
+  inline void set_has_identity();
+  inline void clear_has_identity();
+  inline void set_has_channel_id();
+  inline void clear_has_channel_id();
+  inline void set_has_subscriber();
+  inline void clear_has_subscriber();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::channel::v1::Message* message_;
+  ::google::protobuf::uint64 required_privileges_;
+  ::std::string* identity_;
+  ::bgs::protocol::channel::v1::ChannelId* channel_id_;
+  ::bgs::protocol::account::v1::Identity* subscriber_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto();
+  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SendMessageNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API UpdateChannelStateNotification : public ::google::protobuf::Message {
+ public:
+  UpdateChannelStateNotification();
+  virtual ~UpdateChannelStateNotification();
+
+  UpdateChannelStateNotification(const UpdateChannelStateNotification& from);
+
+  inline UpdateChannelStateNotification& operator=(const UpdateChannelStateNotification& 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 UpdateChannelStateNotification& default_instance();
+
+  void Swap(UpdateChannelStateNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  UpdateChannelStateNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UpdateChannelStateNotification& from);
+  void MergeFrom(const UpdateChannelStateNotification& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.channel.v1.ChannelState state_change = 2;
+  inline bool has_state_change() const;
+  inline void clear_state_change();
+  static const int kStateChangeFieldNumber = 2;
+  inline const ::bgs::protocol::channel::v1::ChannelState& state_change() const;
+  inline ::bgs::protocol::channel::v1::ChannelState* mutable_state_change();
+  inline ::bgs::protocol::channel::v1::ChannelState* release_state_change();
+  inline void set_allocated_state_change(::bgs::protocol::channel::v1::ChannelState* state_change);
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 3;
+  inline bool has_channel_id() const;
+  inline void clear_channel_id();
+  static const int kChannelIdFieldNumber = 3;
+  inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const;
+  inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id();
+  inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id();
+  inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id);
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 4;
+  inline bool has_subscriber() const;
+  inline void clear_subscriber();
+  static const int kSubscriberFieldNumber = 4;
+  inline const ::bgs::protocol::account::v1::Identity& subscriber() const;
+  inline ::bgs::protocol::account::v1::Identity* mutable_subscriber();
+  inline ::bgs::protocol::account::v1::Identity* release_subscriber();
+  inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.UpdateChannelStateNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_state_change();
+  inline void clear_has_state_change();
+  inline void set_has_channel_id();
+  inline void clear_has_channel_id();
+  inline void set_has_subscriber();
+  inline void clear_has_subscriber();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::channel::v1::ChannelState* state_change_;
+  ::bgs::protocol::channel::v1::ChannelId* channel_id_;
+  ::bgs::protocol::account::v1::Identity* subscriber_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto();
+  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static UpdateChannelStateNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API UpdateMemberStateNotification : public ::google::protobuf::Message {
+ public:
+  UpdateMemberStateNotification();
+  virtual ~UpdateMemberStateNotification();
+
+  UpdateMemberStateNotification(const UpdateMemberStateNotification& from);
+
+  inline UpdateMemberStateNotification& operator=(const UpdateMemberStateNotification& 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 UpdateMemberStateNotification& default_instance();
+
+  void Swap(UpdateMemberStateNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  UpdateMemberStateNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UpdateMemberStateNotification& from);
+  void MergeFrom(const UpdateMemberStateNotification& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // repeated .bgs.protocol.channel.v1.Member state_change = 2;
+  inline int state_change_size() const;
+  inline void clear_state_change();
+  static const int kStateChangeFieldNumber = 2;
+  inline const ::bgs::protocol::channel::v1::Member& state_change(int index) const;
+  inline ::bgs::protocol::channel::v1::Member* mutable_state_change(int index);
+  inline ::bgs::protocol::channel::v1::Member* add_state_change();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >&
+      state_change() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >*
+      mutable_state_change();
+
+  // repeated uint32 removed_role = 3 [packed = true];
+  inline int removed_role_size() const;
+  inline void clear_removed_role();
+  static const int kRemovedRoleFieldNumber = 3;
+  inline ::google::protobuf::uint32 removed_role(int index) const;
+  inline void set_removed_role(int index, ::google::protobuf::uint32 value);
+  inline void add_removed_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      removed_role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_removed_role();
+
+  // optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+  inline bool has_channel_id() const;
+  inline void clear_channel_id();
+  static const int kChannelIdFieldNumber = 4;
+  inline const ::bgs::protocol::channel::v1::ChannelId& channel_id() const;
+  inline ::bgs::protocol::channel::v1::ChannelId* mutable_channel_id();
+  inline ::bgs::protocol::channel::v1::ChannelId* release_channel_id();
+  inline void set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id);
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 5;
+  inline bool has_subscriber() const;
+  inline void clear_subscriber();
+  static const int kSubscriberFieldNumber = 5;
+  inline const ::bgs::protocol::account::v1::Identity& subscriber() const;
+  inline ::bgs::protocol::account::v1::Identity* mutable_subscriber();
+  inline ::bgs::protocol::account::v1::Identity* release_subscriber();
+  inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.UpdateMemberStateNotification)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_channel_id();
+  inline void clear_has_channel_id();
+  inline void set_has_subscriber();
+  inline void clear_has_subscriber();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member > state_change_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > removed_role_;
+  mutable int _removed_role_cached_byte_size_;
+  ::bgs::protocol::channel::v1::ChannelId* channel_id_;
+  ::bgs::protocol::account::v1::Identity* subscriber_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5fservice_2eproto();
+  friend void protobuf_AssignDesc_channel_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_channel_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static UpdateMemberStateNotification* default_instance_;
+};
+// ===================================================================
+
+class TC_SHARED_API ChannelService : public ServiceBase
+{
+ public:
+
+  template<typename HashSelector>
+  explicit ChannelService(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  typedef std::integral_constant<uint32, 0xB732DB32u> OriginalHash;
+  typedef std::integral_constant<uint32, 0xA913A87Bu> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void AddMember(::bgs::protocol::channel::v1::AddMemberRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void RemoveMember(::bgs::protocol::channel::v1::RemoveMemberRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void SendMessage(::bgs::protocol::channel::v1::SendMessageRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void UpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void UpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void Dissolve(::bgs::protocol::channel::v1::DissolveRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void SetRoles(::bgs::protocol::channel::v1::SetRolesRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void UnsubscribeMember(::bgs::protocol::channel::v1::UnsubscribeMemberRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleAddMember(::bgs::protocol::channel::v1::AddMemberRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleRemoveMember(::bgs::protocol::channel::v1::RemoveMemberRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleSendMessage(::bgs::protocol::channel::v1::SendMessageRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleDissolve(::bgs::protocol::channel::v1::DissolveRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleSetRoles(::bgs::protocol::channel::v1::SetRolesRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleUnsubscribeMember(::bgs::protocol::channel::v1::UnsubscribeMemberRequest const* request, ::bgs::protocol::NoData* response);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ChannelService);
+};
+
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ChannelListener : public ServiceBase
+{
+ public:
+
+  template<typename HashSelector>
+  explicit ChannelListener(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  typedef std::integral_constant<uint32, 0xBF8C8094u> OriginalHash;
+  typedef std::integral_constant<uint32, 0xDA660990u> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void OnJoin(::bgs::protocol::channel::v1::JoinNotification const* request);
+  void OnMemberAdded(::bgs::protocol::channel::v1::MemberAddedNotification const* request);
+  void OnLeave(::bgs::protocol::channel::v1::LeaveNotification const* request);
+  void OnMemberRemoved(::bgs::protocol::channel::v1::MemberRemovedNotification const* request);
+  void OnSendMessage(::bgs::protocol::channel::v1::SendMessageNotification const* request);
+  void OnUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateNotification const* request);
+  void OnUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateNotification const* request);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleOnJoin(::bgs::protocol::channel::v1::JoinNotification const* request);
+  virtual uint32 HandleOnMemberAdded(::bgs::protocol::channel::v1::MemberAddedNotification const* request);
+  virtual uint32 HandleOnLeave(::bgs::protocol::channel::v1::LeaveNotification const* request);
+  virtual uint32 HandleOnMemberRemoved(::bgs::protocol::channel::v1::MemberRemovedNotification const* request);
+  virtual uint32 HandleOnSendMessage(::bgs::protocol::channel::v1::SendMessageNotification const* request);
+  virtual uint32 HandleOnUpdateChannelState(::bgs::protocol::channel::v1::UpdateChannelStateNotification const* request);
+  virtual uint32 HandleOnUpdateMemberState(::bgs::protocol::channel::v1::UpdateMemberStateNotification const* request);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ChannelListener);
+};
+
+// ===================================================================
+
+
+// ===================================================================
+
+// AddMemberRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool AddMemberRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AddMemberRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AddMemberRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AddMemberRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& AddMemberRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.AddMemberRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* AddMemberRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.AddMemberRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* AddMemberRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void AddMemberRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.AddMemberRequest.agent_id)
+}
+
+// required .bgs.protocol.Identity member_identity = 2;
+inline bool AddMemberRequest::has_member_identity() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AddMemberRequest::set_has_member_identity() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AddMemberRequest::clear_has_member_identity() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AddMemberRequest::clear_member_identity() {
+  if (member_identity_ != NULL) member_identity_->::bgs::protocol::Identity::Clear();
+  clear_has_member_identity();
+}
+inline const ::bgs::protocol::Identity& AddMemberRequest::member_identity() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.AddMemberRequest.member_identity)
+  return member_identity_ != NULL ? *member_identity_ : *default_instance_->member_identity_;
+}
+inline ::bgs::protocol::Identity* AddMemberRequest::mutable_member_identity() {
+  set_has_member_identity();
+  if (member_identity_ == NULL) member_identity_ = new ::bgs::protocol::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.AddMemberRequest.member_identity)
+  return member_identity_;
+}
+inline ::bgs::protocol::Identity* AddMemberRequest::release_member_identity() {
+  clear_has_member_identity();
+  ::bgs::protocol::Identity* temp = member_identity_;
+  member_identity_ = NULL;
+  return temp;
+}
+inline void AddMemberRequest::set_allocated_member_identity(::bgs::protocol::Identity* member_identity) {
+  delete member_identity_;
+  member_identity_ = member_identity;
+  if (member_identity) {
+    set_has_member_identity();
+  } else {
+    clear_has_member_identity();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.AddMemberRequest.member_identity)
+}
+
+// required .bgs.protocol.channel.v1.MemberState member_state = 3;
+inline bool AddMemberRequest::has_member_state() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AddMemberRequest::set_has_member_state() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AddMemberRequest::clear_has_member_state() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AddMemberRequest::clear_member_state() {
+  if (member_state_ != NULL) member_state_->::bgs::protocol::channel::v1::MemberState::Clear();
+  clear_has_member_state();
+}
+inline const ::bgs::protocol::channel::v1::MemberState& AddMemberRequest::member_state() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.AddMemberRequest.member_state)
+  return member_state_ != NULL ? *member_state_ : *default_instance_->member_state_;
+}
+inline ::bgs::protocol::channel::v1::MemberState* AddMemberRequest::mutable_member_state() {
+  set_has_member_state();
+  if (member_state_ == NULL) member_state_ = new ::bgs::protocol::channel::v1::MemberState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.AddMemberRequest.member_state)
+  return member_state_;
+}
+inline ::bgs::protocol::channel::v1::MemberState* AddMemberRequest::release_member_state() {
+  clear_has_member_state();
+  ::bgs::protocol::channel::v1::MemberState* temp = member_state_;
+  member_state_ = NULL;
+  return temp;
+}
+inline void AddMemberRequest::set_allocated_member_state(::bgs::protocol::channel::v1::MemberState* member_state) {
+  delete member_state_;
+  member_state_ = member_state;
+  if (member_state) {
+    set_has_member_state();
+  } else {
+    clear_has_member_state();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.AddMemberRequest.member_state)
+}
+
+// required uint64 object_id = 4;
+inline bool AddMemberRequest::has_object_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void AddMemberRequest::set_has_object_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void AddMemberRequest::clear_has_object_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void AddMemberRequest::clear_object_id() {
+  object_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_object_id();
+}
+inline ::google::protobuf::uint64 AddMemberRequest::object_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.AddMemberRequest.object_id)
+  return object_id_;
+}
+inline void AddMemberRequest::set_object_id(::google::protobuf::uint64 value) {
+  set_has_object_id();
+  object_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.AddMemberRequest.object_id)
+}
+
+// optional bool subscribe = 5 [default = true];
+inline bool AddMemberRequest::has_subscribe() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void AddMemberRequest::set_has_subscribe() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void AddMemberRequest::clear_has_subscribe() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void AddMemberRequest::clear_subscribe() {
+  subscribe_ = true;
+  clear_has_subscribe();
+}
+inline bool AddMemberRequest::subscribe() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.AddMemberRequest.subscribe)
+  return subscribe_;
+}
+inline void AddMemberRequest::set_subscribe(bool value) {
+  set_has_subscribe();
+  subscribe_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.AddMemberRequest.subscribe)
+}
+
+// -------------------------------------------------------------------
+
+// RemoveMemberRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool RemoveMemberRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RemoveMemberRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RemoveMemberRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RemoveMemberRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& RemoveMemberRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.RemoveMemberRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* RemoveMemberRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.RemoveMemberRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* RemoveMemberRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void RemoveMemberRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.RemoveMemberRequest.agent_id)
+}
+
+// required .bgs.protocol.EntityId member_id = 2;
+inline bool RemoveMemberRequest::has_member_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RemoveMemberRequest::set_has_member_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RemoveMemberRequest::clear_has_member_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RemoveMemberRequest::clear_member_id() {
+  if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_member_id();
+}
+inline const ::bgs::protocol::EntityId& RemoveMemberRequest::member_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.RemoveMemberRequest.member_id)
+  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
+}
+inline ::bgs::protocol::EntityId* RemoveMemberRequest::mutable_member_id() {
+  set_has_member_id();
+  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.RemoveMemberRequest.member_id)
+  return member_id_;
+}
+inline ::bgs::protocol::EntityId* RemoveMemberRequest::release_member_id() {
+  clear_has_member_id();
+  ::bgs::protocol::EntityId* temp = member_id_;
+  member_id_ = NULL;
+  return temp;
+}
+inline void RemoveMemberRequest::set_allocated_member_id(::bgs::protocol::EntityId* member_id) {
+  delete member_id_;
+  member_id_ = member_id;
+  if (member_id) {
+    set_has_member_id();
+  } else {
+    clear_has_member_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.RemoveMemberRequest.member_id)
+}
+
+// optional uint32 reason = 3;
+inline bool RemoveMemberRequest::has_reason() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void RemoveMemberRequest::set_has_reason() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void RemoveMemberRequest::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void RemoveMemberRequest::clear_reason() {
+  reason_ = 0u;
+  clear_has_reason();
+}
+inline ::google::protobuf::uint32 RemoveMemberRequest::reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.RemoveMemberRequest.reason)
+  return reason_;
+}
+inline void RemoveMemberRequest::set_reason(::google::protobuf::uint32 value) {
+  set_has_reason();
+  reason_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.RemoveMemberRequest.reason)
+}
+
+// -------------------------------------------------------------------
+
+// UnsubscribeMemberRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool UnsubscribeMemberRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UnsubscribeMemberRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UnsubscribeMemberRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UnsubscribeMemberRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& UnsubscribeMemberRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UnsubscribeMemberRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* UnsubscribeMemberRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UnsubscribeMemberRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* UnsubscribeMemberRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UnsubscribeMemberRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UnsubscribeMemberRequest.agent_id)
+}
+
+// required .bgs.protocol.EntityId member_id = 2;
+inline bool UnsubscribeMemberRequest::has_member_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UnsubscribeMemberRequest::set_has_member_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UnsubscribeMemberRequest::clear_has_member_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UnsubscribeMemberRequest::clear_member_id() {
+  if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_member_id();
+}
+inline const ::bgs::protocol::EntityId& UnsubscribeMemberRequest::member_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UnsubscribeMemberRequest.member_id)
+  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
+}
+inline ::bgs::protocol::EntityId* UnsubscribeMemberRequest::mutable_member_id() {
+  set_has_member_id();
+  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UnsubscribeMemberRequest.member_id)
+  return member_id_;
+}
+inline ::bgs::protocol::EntityId* UnsubscribeMemberRequest::release_member_id() {
+  clear_has_member_id();
+  ::bgs::protocol::EntityId* temp = member_id_;
+  member_id_ = NULL;
+  return temp;
+}
+inline void UnsubscribeMemberRequest::set_allocated_member_id(::bgs::protocol::EntityId* member_id) {
+  delete member_id_;
+  member_id_ = member_id;
+  if (member_id) {
+    set_has_member_id();
+  } else {
+    clear_has_member_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UnsubscribeMemberRequest.member_id)
+}
+
+// -------------------------------------------------------------------
+
+// SendMessageRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool SendMessageRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SendMessageRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SendMessageRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SendMessageRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& SendMessageRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* SendMessageRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* SendMessageRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SendMessageRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageRequest.agent_id)
+}
+
+// required .bgs.protocol.channel.v1.Message message = 2;
+inline bool SendMessageRequest::has_message() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SendMessageRequest::set_has_message() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SendMessageRequest::clear_has_message() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SendMessageRequest::clear_message() {
+  if (message_ != NULL) message_->::bgs::protocol::channel::v1::Message::Clear();
+  clear_has_message();
+}
+inline const ::bgs::protocol::channel::v1::Message& SendMessageRequest::message() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageRequest.message)
+  return message_ != NULL ? *message_ : *default_instance_->message_;
+}
+inline ::bgs::protocol::channel::v1::Message* SendMessageRequest::mutable_message() {
+  set_has_message();
+  if (message_ == NULL) message_ = new ::bgs::protocol::channel::v1::Message;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageRequest.message)
+  return message_;
+}
+inline ::bgs::protocol::channel::v1::Message* SendMessageRequest::release_message() {
+  clear_has_message();
+  ::bgs::protocol::channel::v1::Message* temp = message_;
+  message_ = NULL;
+  return temp;
+}
+inline void SendMessageRequest::set_allocated_message(::bgs::protocol::channel::v1::Message* message) {
+  delete message_;
+  message_ = message;
+  if (message) {
+    set_has_message();
+  } else {
+    clear_has_message();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageRequest.message)
+}
+
+// optional uint64 required_privileges = 3 [default = 0];
+inline bool SendMessageRequest::has_required_privileges() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SendMessageRequest::set_has_required_privileges() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SendMessageRequest::clear_has_required_privileges() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SendMessageRequest::clear_required_privileges() {
+  required_privileges_ = GOOGLE_ULONGLONG(0);
+  clear_has_required_privileges();
+}
+inline ::google::protobuf::uint64 SendMessageRequest::required_privileges() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageRequest.required_privileges)
+  return required_privileges_;
+}
+inline void SendMessageRequest::set_required_privileges(::google::protobuf::uint64 value) {
+  set_has_required_privileges();
+  required_privileges_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.SendMessageRequest.required_privileges)
+}
+
+// -------------------------------------------------------------------
+
+// UpdateChannelStateRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool UpdateChannelStateRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UpdateChannelStateRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UpdateChannelStateRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UpdateChannelStateRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& UpdateChannelStateRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateChannelStateRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateChannelStateRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UpdateChannelStateRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateRequest.agent_id)
+}
+
+// required .bgs.protocol.channel.v1.ChannelState state_change = 2;
+inline bool UpdateChannelStateRequest::has_state_change() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UpdateChannelStateRequest::set_has_state_change() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UpdateChannelStateRequest::clear_has_state_change() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UpdateChannelStateRequest::clear_state_change() {
+  if (state_change_ != NULL) state_change_->::bgs::protocol::channel::v1::ChannelState::Clear();
+  clear_has_state_change();
+}
+inline const ::bgs::protocol::channel::v1::ChannelState& UpdateChannelStateRequest::state_change() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateRequest.state_change)
+  return state_change_ != NULL ? *state_change_ : *default_instance_->state_change_;
+}
+inline ::bgs::protocol::channel::v1::ChannelState* UpdateChannelStateRequest::mutable_state_change() {
+  set_has_state_change();
+  if (state_change_ == NULL) state_change_ = new ::bgs::protocol::channel::v1::ChannelState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateRequest.state_change)
+  return state_change_;
+}
+inline ::bgs::protocol::channel::v1::ChannelState* UpdateChannelStateRequest::release_state_change() {
+  clear_has_state_change();
+  ::bgs::protocol::channel::v1::ChannelState* temp = state_change_;
+  state_change_ = NULL;
+  return temp;
+}
+inline void UpdateChannelStateRequest::set_allocated_state_change(::bgs::protocol::channel::v1::ChannelState* state_change) {
+  delete state_change_;
+  state_change_ = state_change;
+  if (state_change) {
+    set_has_state_change();
+  } else {
+    clear_has_state_change();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateRequest.state_change)
+}
+
+// -------------------------------------------------------------------
+
+// UpdateMemberStateRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool UpdateMemberStateRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UpdateMemberStateRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UpdateMemberStateRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UpdateMemberStateRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& UpdateMemberStateRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateMemberStateRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateMemberStateRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UpdateMemberStateRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateMemberStateRequest.agent_id)
+}
+
+// repeated .bgs.protocol.channel.v1.Member state_change = 2;
+inline int UpdateMemberStateRequest::state_change_size() const {
+  return state_change_.size();
+}
+inline void UpdateMemberStateRequest::clear_state_change() {
+  state_change_.Clear();
+}
+inline const ::bgs::protocol::channel::v1::Member& UpdateMemberStateRequest::state_change(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateRequest.state_change)
+  return state_change_.Get(index);
+}
+inline ::bgs::protocol::channel::v1::Member* UpdateMemberStateRequest::mutable_state_change(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateRequest.state_change)
+  return state_change_.Mutable(index);
+}
+inline ::bgs::protocol::channel::v1::Member* UpdateMemberStateRequest::add_state_change() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.UpdateMemberStateRequest.state_change)
+  return state_change_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >&
+UpdateMemberStateRequest::state_change() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.UpdateMemberStateRequest.state_change)
+  return state_change_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >*
+UpdateMemberStateRequest::mutable_state_change() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.UpdateMemberStateRequest.state_change)
+  return &state_change_;
+}
+
+// repeated uint32 removed_role = 3 [packed = true];
+inline int UpdateMemberStateRequest::removed_role_size() const {
+  return removed_role_.size();
+}
+inline void UpdateMemberStateRequest::clear_removed_role() {
+  removed_role_.Clear();
+}
+inline ::google::protobuf::uint32 UpdateMemberStateRequest::removed_role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateRequest.removed_role)
+  return removed_role_.Get(index);
+}
+inline void UpdateMemberStateRequest::set_removed_role(int index, ::google::protobuf::uint32 value) {
+  removed_role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.UpdateMemberStateRequest.removed_role)
+}
+inline void UpdateMemberStateRequest::add_removed_role(::google::protobuf::uint32 value) {
+  removed_role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.UpdateMemberStateRequest.removed_role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+UpdateMemberStateRequest::removed_role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.UpdateMemberStateRequest.removed_role)
+  return removed_role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+UpdateMemberStateRequest::mutable_removed_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.UpdateMemberStateRequest.removed_role)
+  return &removed_role_;
+}
+
+// -------------------------------------------------------------------
+
+// DissolveRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool DissolveRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void DissolveRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void DissolveRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void DissolveRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& DissolveRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.DissolveRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* DissolveRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.DissolveRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* DissolveRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void DissolveRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.DissolveRequest.agent_id)
+}
+
+// optional uint32 reason = 2;
+inline bool DissolveRequest::has_reason() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void DissolveRequest::set_has_reason() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void DissolveRequest::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void DissolveRequest::clear_reason() {
+  reason_ = 0u;
+  clear_has_reason();
+}
+inline ::google::protobuf::uint32 DissolveRequest::reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.DissolveRequest.reason)
+  return reason_;
+}
+inline void DissolveRequest::set_reason(::google::protobuf::uint32 value) {
+  set_has_reason();
+  reason_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.DissolveRequest.reason)
+}
+
+// -------------------------------------------------------------------
+
+// SetRolesRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool SetRolesRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SetRolesRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SetRolesRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SetRolesRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& SetRolesRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SetRolesRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* SetRolesRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SetRolesRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* SetRolesRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SetRolesRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SetRolesRequest.agent_id)
+}
+
+// repeated uint32 role = 2 [packed = true];
+inline int SetRolesRequest::role_size() const {
+  return role_.size();
+}
+inline void SetRolesRequest::clear_role() {
+  role_.Clear();
+}
+inline ::google::protobuf::uint32 SetRolesRequest::role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SetRolesRequest.role)
+  return role_.Get(index);
+}
+inline void SetRolesRequest::set_role(int index, ::google::protobuf::uint32 value) {
+  role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.SetRolesRequest.role)
+}
+inline void SetRolesRequest::add_role(::google::protobuf::uint32 value) {
+  role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.SetRolesRequest.role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+SetRolesRequest::role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.SetRolesRequest.role)
+  return role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+SetRolesRequest::mutable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.SetRolesRequest.role)
+  return &role_;
+}
+
+// repeated .bgs.protocol.EntityId member_id = 3;
+inline int SetRolesRequest::member_id_size() const {
+  return member_id_.size();
+}
+inline void SetRolesRequest::clear_member_id() {
+  member_id_.Clear();
+}
+inline const ::bgs::protocol::EntityId& SetRolesRequest::member_id(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SetRolesRequest.member_id)
+  return member_id_.Get(index);
+}
+inline ::bgs::protocol::EntityId* SetRolesRequest::mutable_member_id(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SetRolesRequest.member_id)
+  return member_id_.Mutable(index);
+}
+inline ::bgs::protocol::EntityId* SetRolesRequest::add_member_id() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.SetRolesRequest.member_id)
+  return member_id_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >&
+SetRolesRequest::member_id() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.SetRolesRequest.member_id)
+  return member_id_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::EntityId >*
+SetRolesRequest::mutable_member_id() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.SetRolesRequest.member_id)
+  return &member_id_;
+}
+
+// -------------------------------------------------------------------
+
+// JoinNotification
+
+// optional .bgs.protocol.channel.v1.Member self = 1;
+inline bool JoinNotification::has_self() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void JoinNotification::set_has_self() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void JoinNotification::clear_has_self() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void JoinNotification::clear_self() {
+  if (self_ != NULL) self_->::bgs::protocol::channel::v1::Member::Clear();
+  clear_has_self();
+}
+inline const ::bgs::protocol::channel::v1::Member& JoinNotification::self() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.JoinNotification.self)
+  return self_ != NULL ? *self_ : *default_instance_->self_;
+}
+inline ::bgs::protocol::channel::v1::Member* JoinNotification::mutable_self() {
+  set_has_self();
+  if (self_ == NULL) self_ = new ::bgs::protocol::channel::v1::Member;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.JoinNotification.self)
+  return self_;
+}
+inline ::bgs::protocol::channel::v1::Member* JoinNotification::release_self() {
+  clear_has_self();
+  ::bgs::protocol::channel::v1::Member* temp = self_;
+  self_ = NULL;
+  return temp;
+}
+inline void JoinNotification::set_allocated_self(::bgs::protocol::channel::v1::Member* self) {
+  delete self_;
+  self_ = self;
+  if (self) {
+    set_has_self();
+  } else {
+    clear_has_self();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.JoinNotification.self)
+}
+
+// repeated .bgs.protocol.channel.v1.Member member = 2;
+inline int JoinNotification::member_size() const {
+  return member_.size();
+}
+inline void JoinNotification::clear_member() {
+  member_.Clear();
+}
+inline const ::bgs::protocol::channel::v1::Member& JoinNotification::member(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.JoinNotification.member)
+  return member_.Get(index);
+}
+inline ::bgs::protocol::channel::v1::Member* JoinNotification::mutable_member(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.JoinNotification.member)
+  return member_.Mutable(index);
+}
+inline ::bgs::protocol::channel::v1::Member* JoinNotification::add_member() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.JoinNotification.member)
+  return member_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >&
+JoinNotification::member() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.JoinNotification.member)
+  return member_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >*
+JoinNotification::mutable_member() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.JoinNotification.member)
+  return &member_;
+}
+
+// required .bgs.protocol.channel.v1.ChannelState channel_state = 3;
+inline bool JoinNotification::has_channel_state() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void JoinNotification::set_has_channel_state() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void JoinNotification::clear_has_channel_state() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void JoinNotification::clear_channel_state() {
+  if (channel_state_ != NULL) channel_state_->::bgs::protocol::channel::v1::ChannelState::Clear();
+  clear_has_channel_state();
+}
+inline const ::bgs::protocol::channel::v1::ChannelState& JoinNotification::channel_state() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.JoinNotification.channel_state)
+  return channel_state_ != NULL ? *channel_state_ : *default_instance_->channel_state_;
+}
+inline ::bgs::protocol::channel::v1::ChannelState* JoinNotification::mutable_channel_state() {
+  set_has_channel_state();
+  if (channel_state_ == NULL) channel_state_ = new ::bgs::protocol::channel::v1::ChannelState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.JoinNotification.channel_state)
+  return channel_state_;
+}
+inline ::bgs::protocol::channel::v1::ChannelState* JoinNotification::release_channel_state() {
+  clear_has_channel_state();
+  ::bgs::protocol::channel::v1::ChannelState* temp = channel_state_;
+  channel_state_ = NULL;
+  return temp;
+}
+inline void JoinNotification::set_allocated_channel_state(::bgs::protocol::channel::v1::ChannelState* channel_state) {
+  delete channel_state_;
+  channel_state_ = channel_state;
+  if (channel_state) {
+    set_has_channel_state();
+  } else {
+    clear_has_channel_state();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.JoinNotification.channel_state)
+}
+
+// optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+inline bool JoinNotification::has_channel_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void JoinNotification::set_has_channel_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void JoinNotification::clear_has_channel_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void JoinNotification::clear_channel_id() {
+  if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
+  clear_has_channel_id();
+}
+inline const ::bgs::protocol::channel::v1::ChannelId& JoinNotification::channel_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.JoinNotification.channel_id)
+  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
+}
+inline ::bgs::protocol::channel::v1::ChannelId* JoinNotification::mutable_channel_id() {
+  set_has_channel_id();
+  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.JoinNotification.channel_id)
+  return channel_id_;
+}
+inline ::bgs::protocol::channel::v1::ChannelId* JoinNotification::release_channel_id() {
+  clear_has_channel_id();
+  ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_;
+  channel_id_ = NULL;
+  return temp;
+}
+inline void JoinNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) {
+  delete channel_id_;
+  channel_id_ = channel_id;
+  if (channel_id) {
+    set_has_channel_id();
+  } else {
+    clear_has_channel_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.JoinNotification.channel_id)
+}
+
+// optional .bgs.protocol.account.v1.Identity subscriber = 5;
+inline bool JoinNotification::has_subscriber() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void JoinNotification::set_has_subscriber() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void JoinNotification::clear_has_subscriber() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void JoinNotification::clear_subscriber() {
+  if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
+  clear_has_subscriber();
+}
+inline const ::bgs::protocol::account::v1::Identity& JoinNotification::subscriber() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.JoinNotification.subscriber)
+  return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_;
+}
+inline ::bgs::protocol::account::v1::Identity* JoinNotification::mutable_subscriber() {
+  set_has_subscriber();
+  if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.JoinNotification.subscriber)
+  return subscriber_;
+}
+inline ::bgs::protocol::account::v1::Identity* JoinNotification::release_subscriber() {
+  clear_has_subscriber();
+  ::bgs::protocol::account::v1::Identity* temp = subscriber_;
+  subscriber_ = NULL;
+  return temp;
+}
+inline void JoinNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) {
+  delete subscriber_;
+  subscriber_ = subscriber;
+  if (subscriber) {
+    set_has_subscriber();
+  } else {
+    clear_has_subscriber();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.JoinNotification.subscriber)
+}
+
+// -------------------------------------------------------------------
+
+// MemberAddedNotification
+
+// required .bgs.protocol.channel.v1.Member member = 1;
+inline bool MemberAddedNotification::has_member() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MemberAddedNotification::set_has_member() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MemberAddedNotification::clear_has_member() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MemberAddedNotification::clear_member() {
+  if (member_ != NULL) member_->::bgs::protocol::channel::v1::Member::Clear();
+  clear_has_member();
+}
+inline const ::bgs::protocol::channel::v1::Member& MemberAddedNotification::member() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberAddedNotification.member)
+  return member_ != NULL ? *member_ : *default_instance_->member_;
+}
+inline ::bgs::protocol::channel::v1::Member* MemberAddedNotification::mutable_member() {
+  set_has_member();
+  if (member_ == NULL) member_ = new ::bgs::protocol::channel::v1::Member;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberAddedNotification.member)
+  return member_;
+}
+inline ::bgs::protocol::channel::v1::Member* MemberAddedNotification::release_member() {
+  clear_has_member();
+  ::bgs::protocol::channel::v1::Member* temp = member_;
+  member_ = NULL;
+  return temp;
+}
+inline void MemberAddedNotification::set_allocated_member(::bgs::protocol::channel::v1::Member* member) {
+  delete member_;
+  member_ = member;
+  if (member) {
+    set_has_member();
+  } else {
+    clear_has_member();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberAddedNotification.member)
+}
+
+// optional .bgs.protocol.channel.v1.ChannelId channel_id = 2;
+inline bool MemberAddedNotification::has_channel_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MemberAddedNotification::set_has_channel_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MemberAddedNotification::clear_has_channel_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MemberAddedNotification::clear_channel_id() {
+  if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
+  clear_has_channel_id();
+}
+inline const ::bgs::protocol::channel::v1::ChannelId& MemberAddedNotification::channel_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberAddedNotification.channel_id)
+  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
+}
+inline ::bgs::protocol::channel::v1::ChannelId* MemberAddedNotification::mutable_channel_id() {
+  set_has_channel_id();
+  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberAddedNotification.channel_id)
+  return channel_id_;
+}
+inline ::bgs::protocol::channel::v1::ChannelId* MemberAddedNotification::release_channel_id() {
+  clear_has_channel_id();
+  ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_;
+  channel_id_ = NULL;
+  return temp;
+}
+inline void MemberAddedNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) {
+  delete channel_id_;
+  channel_id_ = channel_id;
+  if (channel_id) {
+    set_has_channel_id();
+  } else {
+    clear_has_channel_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberAddedNotification.channel_id)
+}
+
+// optional .bgs.protocol.account.v1.Identity subscriber = 3;
+inline bool MemberAddedNotification::has_subscriber() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void MemberAddedNotification::set_has_subscriber() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void MemberAddedNotification::clear_has_subscriber() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void MemberAddedNotification::clear_subscriber() {
+  if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
+  clear_has_subscriber();
+}
+inline const ::bgs::protocol::account::v1::Identity& MemberAddedNotification::subscriber() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberAddedNotification.subscriber)
+  return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_;
+}
+inline ::bgs::protocol::account::v1::Identity* MemberAddedNotification::mutable_subscriber() {
+  set_has_subscriber();
+  if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberAddedNotification.subscriber)
+  return subscriber_;
+}
+inline ::bgs::protocol::account::v1::Identity* MemberAddedNotification::release_subscriber() {
+  clear_has_subscriber();
+  ::bgs::protocol::account::v1::Identity* temp = subscriber_;
+  subscriber_ = NULL;
+  return temp;
+}
+inline void MemberAddedNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) {
+  delete subscriber_;
+  subscriber_ = subscriber;
+  if (subscriber) {
+    set_has_subscriber();
+  } else {
+    clear_has_subscriber();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberAddedNotification.subscriber)
+}
+
+// -------------------------------------------------------------------
+
+// LeaveNotification
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool LeaveNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void LeaveNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void LeaveNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void LeaveNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& LeaveNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.LeaveNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* LeaveNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.LeaveNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* LeaveNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void LeaveNotification::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.LeaveNotification.agent_id)
+}
+
+// required .bgs.protocol.EntityId member_id = 2;
+inline bool LeaveNotification::has_member_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void LeaveNotification::set_has_member_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void LeaveNotification::clear_has_member_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void LeaveNotification::clear_member_id() {
+  if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_member_id();
+}
+inline const ::bgs::protocol::EntityId& LeaveNotification::member_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.LeaveNotification.member_id)
+  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
+}
+inline ::bgs::protocol::EntityId* LeaveNotification::mutable_member_id() {
+  set_has_member_id();
+  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.LeaveNotification.member_id)
+  return member_id_;
+}
+inline ::bgs::protocol::EntityId* LeaveNotification::release_member_id() {
+  clear_has_member_id();
+  ::bgs::protocol::EntityId* temp = member_id_;
+  member_id_ = NULL;
+  return temp;
+}
+inline void LeaveNotification::set_allocated_member_id(::bgs::protocol::EntityId* member_id) {
+  delete member_id_;
+  member_id_ = member_id;
+  if (member_id) {
+    set_has_member_id();
+  } else {
+    clear_has_member_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.LeaveNotification.member_id)
+}
+
+// optional uint32 reason = 3;
+inline bool LeaveNotification::has_reason() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void LeaveNotification::set_has_reason() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void LeaveNotification::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void LeaveNotification::clear_reason() {
+  reason_ = 0u;
+  clear_has_reason();
+}
+inline ::google::protobuf::uint32 LeaveNotification::reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.LeaveNotification.reason)
+  return reason_;
+}
+inline void LeaveNotification::set_reason(::google::protobuf::uint32 value) {
+  set_has_reason();
+  reason_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.LeaveNotification.reason)
+}
+
+// optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+inline bool LeaveNotification::has_channel_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void LeaveNotification::set_has_channel_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void LeaveNotification::clear_has_channel_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void LeaveNotification::clear_channel_id() {
+  if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
+  clear_has_channel_id();
+}
+inline const ::bgs::protocol::channel::v1::ChannelId& LeaveNotification::channel_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.LeaveNotification.channel_id)
+  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
+}
+inline ::bgs::protocol::channel::v1::ChannelId* LeaveNotification::mutable_channel_id() {
+  set_has_channel_id();
+  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.LeaveNotification.channel_id)
+  return channel_id_;
+}
+inline ::bgs::protocol::channel::v1::ChannelId* LeaveNotification::release_channel_id() {
+  clear_has_channel_id();
+  ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_;
+  channel_id_ = NULL;
+  return temp;
+}
+inline void LeaveNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) {
+  delete channel_id_;
+  channel_id_ = channel_id;
+  if (channel_id) {
+    set_has_channel_id();
+  } else {
+    clear_has_channel_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.LeaveNotification.channel_id)
+}
+
+// optional .bgs.protocol.account.v1.Identity subscriber = 5;
+inline bool LeaveNotification::has_subscriber() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void LeaveNotification::set_has_subscriber() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void LeaveNotification::clear_has_subscriber() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void LeaveNotification::clear_subscriber() {
+  if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
+  clear_has_subscriber();
+}
+inline const ::bgs::protocol::account::v1::Identity& LeaveNotification::subscriber() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.LeaveNotification.subscriber)
+  return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_;
+}
+inline ::bgs::protocol::account::v1::Identity* LeaveNotification::mutable_subscriber() {
+  set_has_subscriber();
+  if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.LeaveNotification.subscriber)
+  return subscriber_;
+}
+inline ::bgs::protocol::account::v1::Identity* LeaveNotification::release_subscriber() {
+  clear_has_subscriber();
+  ::bgs::protocol::account::v1::Identity* temp = subscriber_;
+  subscriber_ = NULL;
+  return temp;
+}
+inline void LeaveNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) {
+  delete subscriber_;
+  subscriber_ = subscriber;
+  if (subscriber) {
+    set_has_subscriber();
+  } else {
+    clear_has_subscriber();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.LeaveNotification.subscriber)
+}
+
+// -------------------------------------------------------------------
+
+// MemberRemovedNotification
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool MemberRemovedNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MemberRemovedNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MemberRemovedNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MemberRemovedNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& MemberRemovedNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberRemovedNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* MemberRemovedNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberRemovedNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* MemberRemovedNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void MemberRemovedNotification::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberRemovedNotification.agent_id)
+}
+
+// required .bgs.protocol.EntityId member_id = 2;
+inline bool MemberRemovedNotification::has_member_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MemberRemovedNotification::set_has_member_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MemberRemovedNotification::clear_has_member_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MemberRemovedNotification::clear_member_id() {
+  if (member_id_ != NULL) member_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_member_id();
+}
+inline const ::bgs::protocol::EntityId& MemberRemovedNotification::member_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberRemovedNotification.member_id)
+  return member_id_ != NULL ? *member_id_ : *default_instance_->member_id_;
+}
+inline ::bgs::protocol::EntityId* MemberRemovedNotification::mutable_member_id() {
+  set_has_member_id();
+  if (member_id_ == NULL) member_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberRemovedNotification.member_id)
+  return member_id_;
+}
+inline ::bgs::protocol::EntityId* MemberRemovedNotification::release_member_id() {
+  clear_has_member_id();
+  ::bgs::protocol::EntityId* temp = member_id_;
+  member_id_ = NULL;
+  return temp;
+}
+inline void MemberRemovedNotification::set_allocated_member_id(::bgs::protocol::EntityId* member_id) {
+  delete member_id_;
+  member_id_ = member_id;
+  if (member_id) {
+    set_has_member_id();
+  } else {
+    clear_has_member_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberRemovedNotification.member_id)
+}
+
+// optional uint32 reason = 3;
+inline bool MemberRemovedNotification::has_reason() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void MemberRemovedNotification::set_has_reason() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void MemberRemovedNotification::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void MemberRemovedNotification::clear_reason() {
+  reason_ = 0u;
+  clear_has_reason();
+}
+inline ::google::protobuf::uint32 MemberRemovedNotification::reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberRemovedNotification.reason)
+  return reason_;
+}
+inline void MemberRemovedNotification::set_reason(::google::protobuf::uint32 value) {
+  set_has_reason();
+  reason_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.MemberRemovedNotification.reason)
+}
+
+// optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+inline bool MemberRemovedNotification::has_channel_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void MemberRemovedNotification::set_has_channel_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void MemberRemovedNotification::clear_has_channel_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void MemberRemovedNotification::clear_channel_id() {
+  if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
+  clear_has_channel_id();
+}
+inline const ::bgs::protocol::channel::v1::ChannelId& MemberRemovedNotification::channel_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberRemovedNotification.channel_id)
+  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
+}
+inline ::bgs::protocol::channel::v1::ChannelId* MemberRemovedNotification::mutable_channel_id() {
+  set_has_channel_id();
+  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberRemovedNotification.channel_id)
+  return channel_id_;
+}
+inline ::bgs::protocol::channel::v1::ChannelId* MemberRemovedNotification::release_channel_id() {
+  clear_has_channel_id();
+  ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_;
+  channel_id_ = NULL;
+  return temp;
+}
+inline void MemberRemovedNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) {
+  delete channel_id_;
+  channel_id_ = channel_id;
+  if (channel_id) {
+    set_has_channel_id();
+  } else {
+    clear_has_channel_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberRemovedNotification.channel_id)
+}
+
+// optional .bgs.protocol.account.v1.Identity subscriber = 5;
+inline bool MemberRemovedNotification::has_subscriber() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void MemberRemovedNotification::set_has_subscriber() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void MemberRemovedNotification::clear_has_subscriber() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void MemberRemovedNotification::clear_subscriber() {
+  if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
+  clear_has_subscriber();
+}
+inline const ::bgs::protocol::account::v1::Identity& MemberRemovedNotification::subscriber() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberRemovedNotification.subscriber)
+  return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_;
+}
+inline ::bgs::protocol::account::v1::Identity* MemberRemovedNotification::mutable_subscriber() {
+  set_has_subscriber();
+  if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberRemovedNotification.subscriber)
+  return subscriber_;
+}
+inline ::bgs::protocol::account::v1::Identity* MemberRemovedNotification::release_subscriber() {
+  clear_has_subscriber();
+  ::bgs::protocol::account::v1::Identity* temp = subscriber_;
+  subscriber_ = NULL;
+  return temp;
+}
+inline void MemberRemovedNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) {
+  delete subscriber_;
+  subscriber_ = subscriber;
+  if (subscriber) {
+    set_has_subscriber();
+  } else {
+    clear_has_subscriber();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberRemovedNotification.subscriber)
+}
+
+// -------------------------------------------------------------------
+
+// SendMessageNotification
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool SendMessageNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SendMessageNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SendMessageNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SendMessageNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& SendMessageNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* SendMessageNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* SendMessageNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SendMessageNotification::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageNotification.agent_id)
+}
+
+// required .bgs.protocol.channel.v1.Message message = 2;
+inline bool SendMessageNotification::has_message() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SendMessageNotification::set_has_message() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SendMessageNotification::clear_has_message() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SendMessageNotification::clear_message() {
+  if (message_ != NULL) message_->::bgs::protocol::channel::v1::Message::Clear();
+  clear_has_message();
+}
+inline const ::bgs::protocol::channel::v1::Message& SendMessageNotification::message() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.message)
+  return message_ != NULL ? *message_ : *default_instance_->message_;
+}
+inline ::bgs::protocol::channel::v1::Message* SendMessageNotification::mutable_message() {
+  set_has_message();
+  if (message_ == NULL) message_ = new ::bgs::protocol::channel::v1::Message;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageNotification.message)
+  return message_;
+}
+inline ::bgs::protocol::channel::v1::Message* SendMessageNotification::release_message() {
+  clear_has_message();
+  ::bgs::protocol::channel::v1::Message* temp = message_;
+  message_ = NULL;
+  return temp;
+}
+inline void SendMessageNotification::set_allocated_message(::bgs::protocol::channel::v1::Message* message) {
+  delete message_;
+  message_ = message;
+  if (message) {
+    set_has_message();
+  } else {
+    clear_has_message();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageNotification.message)
+}
+
+// optional uint64 required_privileges = 3 [default = 0];
+inline bool SendMessageNotification::has_required_privileges() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SendMessageNotification::set_has_required_privileges() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SendMessageNotification::clear_has_required_privileges() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SendMessageNotification::clear_required_privileges() {
+  required_privileges_ = GOOGLE_ULONGLONG(0);
+  clear_has_required_privileges();
+}
+inline ::google::protobuf::uint64 SendMessageNotification::required_privileges() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.required_privileges)
+  return required_privileges_;
+}
+inline void SendMessageNotification::set_required_privileges(::google::protobuf::uint64 value) {
+  set_has_required_privileges();
+  required_privileges_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.SendMessageNotification.required_privileges)
+}
+
+// optional string identity = 4;
+inline bool SendMessageNotification::has_identity() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void SendMessageNotification::set_has_identity() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void SendMessageNotification::clear_has_identity() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void SendMessageNotification::clear_identity() {
+  if (identity_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    identity_->clear();
+  }
+  clear_has_identity();
+}
+inline const ::std::string& SendMessageNotification::identity() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.identity)
+  return *identity_;
+}
+inline void SendMessageNotification::set_identity(const ::std::string& value) {
+  set_has_identity();
+  if (identity_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    identity_ = new ::std::string;
+  }
+  identity_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.SendMessageNotification.identity)
+}
+inline void SendMessageNotification::set_identity(const char* value) {
+  set_has_identity();
+  if (identity_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    identity_ = new ::std::string;
+  }
+  identity_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.SendMessageNotification.identity)
+}
+inline void SendMessageNotification::set_identity(const char* value, size_t size) {
+  set_has_identity();
+  if (identity_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    identity_ = new ::std::string;
+  }
+  identity_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.SendMessageNotification.identity)
+}
+inline ::std::string* SendMessageNotification::mutable_identity() {
+  set_has_identity();
+  if (identity_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    identity_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageNotification.identity)
+  return identity_;
+}
+inline ::std::string* SendMessageNotification::release_identity() {
+  clear_has_identity();
+  if (identity_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = identity_;
+    identity_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void SendMessageNotification::set_allocated_identity(::std::string* identity) {
+  if (identity_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete identity_;
+  }
+  if (identity) {
+    set_has_identity();
+    identity_ = identity;
+  } else {
+    clear_has_identity();
+    identity_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageNotification.identity)
+}
+
+// optional .bgs.protocol.channel.v1.ChannelId channel_id = 5;
+inline bool SendMessageNotification::has_channel_id() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void SendMessageNotification::set_has_channel_id() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void SendMessageNotification::clear_has_channel_id() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void SendMessageNotification::clear_channel_id() {
+  if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
+  clear_has_channel_id();
+}
+inline const ::bgs::protocol::channel::v1::ChannelId& SendMessageNotification::channel_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.channel_id)
+  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
+}
+inline ::bgs::protocol::channel::v1::ChannelId* SendMessageNotification::mutable_channel_id() {
+  set_has_channel_id();
+  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageNotification.channel_id)
+  return channel_id_;
+}
+inline ::bgs::protocol::channel::v1::ChannelId* SendMessageNotification::release_channel_id() {
+  clear_has_channel_id();
+  ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_;
+  channel_id_ = NULL;
+  return temp;
+}
+inline void SendMessageNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) {
+  delete channel_id_;
+  channel_id_ = channel_id;
+  if (channel_id) {
+    set_has_channel_id();
+  } else {
+    clear_has_channel_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageNotification.channel_id)
+}
+
+// optional .bgs.protocol.account.v1.Identity subscriber = 6;
+inline bool SendMessageNotification::has_subscriber() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void SendMessageNotification::set_has_subscriber() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void SendMessageNotification::clear_has_subscriber() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void SendMessageNotification::clear_subscriber() {
+  if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
+  clear_has_subscriber();
+}
+inline const ::bgs::protocol::account::v1::Identity& SendMessageNotification::subscriber() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SendMessageNotification.subscriber)
+  return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_;
+}
+inline ::bgs::protocol::account::v1::Identity* SendMessageNotification::mutable_subscriber() {
+  set_has_subscriber();
+  if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SendMessageNotification.subscriber)
+  return subscriber_;
+}
+inline ::bgs::protocol::account::v1::Identity* SendMessageNotification::release_subscriber() {
+  clear_has_subscriber();
+  ::bgs::protocol::account::v1::Identity* temp = subscriber_;
+  subscriber_ = NULL;
+  return temp;
+}
+inline void SendMessageNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) {
+  delete subscriber_;
+  subscriber_ = subscriber;
+  if (subscriber) {
+    set_has_subscriber();
+  } else {
+    clear_has_subscriber();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SendMessageNotification.subscriber)
+}
+
+// -------------------------------------------------------------------
+
+// UpdateChannelStateNotification
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool UpdateChannelStateNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UpdateChannelStateNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UpdateChannelStateNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UpdateChannelStateNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& UpdateChannelStateNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateChannelStateNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateChannelStateNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UpdateChannelStateNotification::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateNotification.agent_id)
+}
+
+// required .bgs.protocol.channel.v1.ChannelState state_change = 2;
+inline bool UpdateChannelStateNotification::has_state_change() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UpdateChannelStateNotification::set_has_state_change() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UpdateChannelStateNotification::clear_has_state_change() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UpdateChannelStateNotification::clear_state_change() {
+  if (state_change_ != NULL) state_change_->::bgs::protocol::channel::v1::ChannelState::Clear();
+  clear_has_state_change();
+}
+inline const ::bgs::protocol::channel::v1::ChannelState& UpdateChannelStateNotification::state_change() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateNotification.state_change)
+  return state_change_ != NULL ? *state_change_ : *default_instance_->state_change_;
+}
+inline ::bgs::protocol::channel::v1::ChannelState* UpdateChannelStateNotification::mutable_state_change() {
+  set_has_state_change();
+  if (state_change_ == NULL) state_change_ = new ::bgs::protocol::channel::v1::ChannelState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateNotification.state_change)
+  return state_change_;
+}
+inline ::bgs::protocol::channel::v1::ChannelState* UpdateChannelStateNotification::release_state_change() {
+  clear_has_state_change();
+  ::bgs::protocol::channel::v1::ChannelState* temp = state_change_;
+  state_change_ = NULL;
+  return temp;
+}
+inline void UpdateChannelStateNotification::set_allocated_state_change(::bgs::protocol::channel::v1::ChannelState* state_change) {
+  delete state_change_;
+  state_change_ = state_change;
+  if (state_change) {
+    set_has_state_change();
+  } else {
+    clear_has_state_change();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateNotification.state_change)
+}
+
+// optional .bgs.protocol.channel.v1.ChannelId channel_id = 3;
+inline bool UpdateChannelStateNotification::has_channel_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void UpdateChannelStateNotification::set_has_channel_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void UpdateChannelStateNotification::clear_has_channel_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void UpdateChannelStateNotification::clear_channel_id() {
+  if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
+  clear_has_channel_id();
+}
+inline const ::bgs::protocol::channel::v1::ChannelId& UpdateChannelStateNotification::channel_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateNotification.channel_id)
+  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
+}
+inline ::bgs::protocol::channel::v1::ChannelId* UpdateChannelStateNotification::mutable_channel_id() {
+  set_has_channel_id();
+  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateNotification.channel_id)
+  return channel_id_;
+}
+inline ::bgs::protocol::channel::v1::ChannelId* UpdateChannelStateNotification::release_channel_id() {
+  clear_has_channel_id();
+  ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_;
+  channel_id_ = NULL;
+  return temp;
+}
+inline void UpdateChannelStateNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) {
+  delete channel_id_;
+  channel_id_ = channel_id;
+  if (channel_id) {
+    set_has_channel_id();
+  } else {
+    clear_has_channel_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateNotification.channel_id)
+}
+
+// optional .bgs.protocol.account.v1.Identity subscriber = 4;
+inline bool UpdateChannelStateNotification::has_subscriber() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void UpdateChannelStateNotification::set_has_subscriber() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void UpdateChannelStateNotification::clear_has_subscriber() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void UpdateChannelStateNotification::clear_subscriber() {
+  if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
+  clear_has_subscriber();
+}
+inline const ::bgs::protocol::account::v1::Identity& UpdateChannelStateNotification::subscriber() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateChannelStateNotification.subscriber)
+  return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_;
+}
+inline ::bgs::protocol::account::v1::Identity* UpdateChannelStateNotification::mutable_subscriber() {
+  set_has_subscriber();
+  if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateChannelStateNotification.subscriber)
+  return subscriber_;
+}
+inline ::bgs::protocol::account::v1::Identity* UpdateChannelStateNotification::release_subscriber() {
+  clear_has_subscriber();
+  ::bgs::protocol::account::v1::Identity* temp = subscriber_;
+  subscriber_ = NULL;
+  return temp;
+}
+inline void UpdateChannelStateNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) {
+  delete subscriber_;
+  subscriber_ = subscriber;
+  if (subscriber) {
+    set_has_subscriber();
+  } else {
+    clear_has_subscriber();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateChannelStateNotification.subscriber)
+}
+
+// -------------------------------------------------------------------
+
+// UpdateMemberStateNotification
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool UpdateMemberStateNotification::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UpdateMemberStateNotification::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UpdateMemberStateNotification::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UpdateMemberStateNotification::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& UpdateMemberStateNotification::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateNotification.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateMemberStateNotification::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateNotification.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateMemberStateNotification::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UpdateMemberStateNotification::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateMemberStateNotification.agent_id)
+}
+
+// repeated .bgs.protocol.channel.v1.Member state_change = 2;
+inline int UpdateMemberStateNotification::state_change_size() const {
+  return state_change_.size();
+}
+inline void UpdateMemberStateNotification::clear_state_change() {
+  state_change_.Clear();
+}
+inline const ::bgs::protocol::channel::v1::Member& UpdateMemberStateNotification::state_change(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateNotification.state_change)
+  return state_change_.Get(index);
+}
+inline ::bgs::protocol::channel::v1::Member* UpdateMemberStateNotification::mutable_state_change(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateNotification.state_change)
+  return state_change_.Mutable(index);
+}
+inline ::bgs::protocol::channel::v1::Member* UpdateMemberStateNotification::add_state_change() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.UpdateMemberStateNotification.state_change)
+  return state_change_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >&
+UpdateMemberStateNotification::state_change() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.UpdateMemberStateNotification.state_change)
+  return state_change_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >*
+UpdateMemberStateNotification::mutable_state_change() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.UpdateMemberStateNotification.state_change)
+  return &state_change_;
+}
+
+// repeated uint32 removed_role = 3 [packed = true];
+inline int UpdateMemberStateNotification::removed_role_size() const {
+  return removed_role_.size();
+}
+inline void UpdateMemberStateNotification::clear_removed_role() {
+  removed_role_.Clear();
+}
+inline ::google::protobuf::uint32 UpdateMemberStateNotification::removed_role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateNotification.removed_role)
+  return removed_role_.Get(index);
+}
+inline void UpdateMemberStateNotification::set_removed_role(int index, ::google::protobuf::uint32 value) {
+  removed_role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.UpdateMemberStateNotification.removed_role)
+}
+inline void UpdateMemberStateNotification::add_removed_role(::google::protobuf::uint32 value) {
+  removed_role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.UpdateMemberStateNotification.removed_role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+UpdateMemberStateNotification::removed_role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.UpdateMemberStateNotification.removed_role)
+  return removed_role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+UpdateMemberStateNotification::mutable_removed_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.UpdateMemberStateNotification.removed_role)
+  return &removed_role_;
+}
+
+// optional .bgs.protocol.channel.v1.ChannelId channel_id = 4;
+inline bool UpdateMemberStateNotification::has_channel_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void UpdateMemberStateNotification::set_has_channel_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void UpdateMemberStateNotification::clear_has_channel_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void UpdateMemberStateNotification::clear_channel_id() {
+  if (channel_id_ != NULL) channel_id_->::bgs::protocol::channel::v1::ChannelId::Clear();
+  clear_has_channel_id();
+}
+inline const ::bgs::protocol::channel::v1::ChannelId& UpdateMemberStateNotification::channel_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateNotification.channel_id)
+  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
+}
+inline ::bgs::protocol::channel::v1::ChannelId* UpdateMemberStateNotification::mutable_channel_id() {
+  set_has_channel_id();
+  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::channel::v1::ChannelId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateNotification.channel_id)
+  return channel_id_;
+}
+inline ::bgs::protocol::channel::v1::ChannelId* UpdateMemberStateNotification::release_channel_id() {
+  clear_has_channel_id();
+  ::bgs::protocol::channel::v1::ChannelId* temp = channel_id_;
+  channel_id_ = NULL;
+  return temp;
+}
+inline void UpdateMemberStateNotification::set_allocated_channel_id(::bgs::protocol::channel::v1::ChannelId* channel_id) {
+  delete channel_id_;
+  channel_id_ = channel_id;
+  if (channel_id) {
+    set_has_channel_id();
+  } else {
+    clear_has_channel_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateMemberStateNotification.channel_id)
+}
+
+// optional .bgs.protocol.account.v1.Identity subscriber = 5;
+inline bool UpdateMemberStateNotification::has_subscriber() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void UpdateMemberStateNotification::set_has_subscriber() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void UpdateMemberStateNotification::clear_has_subscriber() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void UpdateMemberStateNotification::clear_subscriber() {
+  if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
+  clear_has_subscriber();
+}
+inline const ::bgs::protocol::account::v1::Identity& UpdateMemberStateNotification::subscriber() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.UpdateMemberStateNotification.subscriber)
+  return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_;
+}
+inline ::bgs::protocol::account::v1::Identity* UpdateMemberStateNotification::mutable_subscriber() {
+  set_has_subscriber();
+  if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.UpdateMemberStateNotification.subscriber)
+  return subscriber_;
+}
+inline ::bgs::protocol::account::v1::Identity* UpdateMemberStateNotification::release_subscriber() {
+  clear_has_subscriber();
+  ::bgs::protocol::account::v1::Identity* temp = subscriber_;
+  subscriber_ = NULL;
+  return temp;
+}
+inline void UpdateMemberStateNotification::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) {
+  delete subscriber_;
+  subscriber_ = subscriber;
+  if (subscriber) {
+    set_has_subscriber();
+  } else {
+    clear_has_subscriber();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.UpdateMemberStateNotification.subscriber)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace channel
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_channel_5fservice_2eproto__INCLUDED
diff --git a/src/server/proto/Client/channel_types.pb.cc b/src/server/proto/Client/channel_types.pb.cc
new file mode 100644
index 00000000000..b7f3bd56cc6
--- /dev/null
+++ b/src/server/proto/Client/channel_types.pb.cc
@@ -0,0 +1,3717 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: channel_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "channel_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace channel {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* ChannelId_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ChannelId_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Message_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Message_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ListChannelsOptions_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ListChannelsOptions_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ChannelDescription_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ChannelDescription_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ChannelInfo_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ChannelInfo_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ChannelState_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ChannelState_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* ChannelState_PrivacyLevel_descriptor_ = NULL;
+const ::google::protobuf::Descriptor* MemberState_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  MemberState_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Member_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Member_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_channel_5ftypes_2eproto() {
+  protobuf_AddDesc_channel_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "channel_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  ChannelId_descriptor_ = file->message_type(0);
+  static const int ChannelId_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelId, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelId, host_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelId, id_),
+  };
+  ChannelId_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ChannelId_descriptor_,
+      ChannelId::default_instance_,
+      ChannelId_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelId, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelId, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ChannelId));
+  Message_descriptor_ = file->message_type(1);
+  static const int Message_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Message, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Message, role_),
+  };
+  Message_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Message_descriptor_,
+      Message::default_instance_,
+      Message_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Message, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Message, _unknown_fields_),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Message, _extensions_),
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Message));
+  ListChannelsOptions_descriptor_ = file->message_type(2);
+  static const int ListChannelsOptions_offsets_[8] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, start_index_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, max_results_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, locale_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, capacity_full_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, attribute_filter_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, channel_type_),
+  };
+  ListChannelsOptions_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ListChannelsOptions_descriptor_,
+      ListChannelsOptions::default_instance_,
+      ListChannelsOptions_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, _unknown_fields_),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ListChannelsOptions, _extensions_),
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ListChannelsOptions));
+  ChannelDescription_descriptor_ = file->message_type(3);
+  static const int ChannelDescription_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelDescription, channel_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelDescription, current_members_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelDescription, state_),
+  };
+  ChannelDescription_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ChannelDescription_descriptor_,
+      ChannelDescription::default_instance_,
+      ChannelDescription_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelDescription, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelDescription, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ChannelDescription));
+  ChannelInfo_descriptor_ = file->message_type(4);
+  static const int ChannelInfo_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelInfo, description_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelInfo, member_),
+  };
+  ChannelInfo_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ChannelInfo_descriptor_,
+      ChannelInfo::default_instance_,
+      ChannelInfo_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelInfo, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelInfo, _unknown_fields_),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelInfo, _extensions_),
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ChannelInfo));
+  ChannelState_descriptor_ = file->message_type(5);
+  static const int ChannelState_offsets_[14] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, max_members_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, min_members_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, invitation_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, max_invitations_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, reason_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, privacy_level_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, delegate_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, channel_type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, allow_offline_members_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, subscribe_to_presence_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, destroy_on_founder_leave_),
+  };
+  ChannelState_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ChannelState_descriptor_,
+      ChannelState::default_instance_,
+      ChannelState_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, _unknown_fields_),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, _extensions_),
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ChannelState));
+  ChannelState_PrivacyLevel_descriptor_ = ChannelState_descriptor_->enum_type(0);
+  MemberState_descriptor_ = file->message_type(6);
+  static const int MemberState_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberState, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberState, role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberState, privileges_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberState, info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberState, deprecated_hidden_),
+  };
+  MemberState_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      MemberState_descriptor_,
+      MemberState::default_instance_,
+      MemberState_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberState, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberState, _unknown_fields_),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MemberState, _extensions_),
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(MemberState));
+  Member_descriptor_ = file->message_type(7);
+  static const int Member_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, identity_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, state_),
+  };
+  Member_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Member_descriptor_,
+      Member::default_instance_,
+      Member_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Member, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Member));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_channel_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ChannelId_descriptor_, &ChannelId::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Message_descriptor_, &Message::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ListChannelsOptions_descriptor_, &ListChannelsOptions::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ChannelDescription_descriptor_, &ChannelDescription::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ChannelInfo_descriptor_, &ChannelInfo::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ChannelState_descriptor_, &ChannelState::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    MemberState_descriptor_, &MemberState::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Member_descriptor_, &Member::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_channel_5ftypes_2eproto() {
+  delete ChannelId::default_instance_;
+  delete ChannelId_reflection_;
+  delete Message::default_instance_;
+  delete Message_reflection_;
+  delete ListChannelsOptions::default_instance_;
+  delete ListChannelsOptions_reflection_;
+  delete ChannelDescription::default_instance_;
+  delete ChannelDescription_reflection_;
+  delete ChannelInfo::default_instance_;
+  delete ChannelInfo_reflection_;
+  delete ChannelState::default_instance_;
+  delete ChannelState_reflection_;
+  delete ChannelState::_default_channel_type_;
+  delete MemberState::default_instance_;
+  delete MemberState_reflection_;
+  delete Member::default_instance_;
+  delete Member_reflection_;
+}
+
+void protobuf_AddDesc_channel_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_invitation_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\023channel_types.proto\022\027bgs.protocol.chan"
+    "nel.v1\032\025attribute_types.proto\032\022entity_ty"
+    "pes.proto\032\026invitation_types.proto\032\017rpc_t"
+    "ypes.proto\"L\n\tChannelId\022\014\n\004type\030\001 \001(\r\022%\n"
+    "\004host\030\002 \001(\0132\027.bgs.protocol.ProcessId\022\n\n\002"
+    "id\030\003 \001(\007\"J\n\007Message\022*\n\tattribute\030\001 \003(\0132\027"
+    ".bgs.protocol.Attribute\022\014\n\004role\030\002 \001(\r*\005\010"
+    "d\020\220N\"\342\001\n\023ListChannelsOptions\022\026\n\013start_in"
+    "dex\030\001 \001(\r:\0010\022\027\n\013max_results\030\002 \001(\r:\00216\022\014\n"
+    "\004name\030\003 \001(\t\022\017\n\007program\030\004 \001(\007\022\016\n\006locale\030\005"
+    " \001(\007\022\025\n\rcapacity_full\030\006 \001(\r\0227\n\020attribute"
+    "_filter\030\007 \002(\0132\035.bgs.protocol.AttributeFi"
+    "lter\022\024\n\014channel_type\030\010 \001(\t*\005\010d\020\220N\"\217\001\n\022Ch"
+    "annelDescription\022*\n\nchannel_id\030\001 \002(\0132\026.b"
+    "gs.protocol.EntityId\022\027\n\017current_members\030"
+    "\002 \001(\r\0224\n\005state\030\003 \001(\0132%.bgs.protocol.chan"
+    "nel.v1.ChannelState\"\207\001\n\013ChannelInfo\022@\n\013d"
+    "escription\030\001 \002(\0132+.bgs.protocol.channel."
+    "v1.ChannelDescription\022/\n\006member\030\002 \003(\0132\037."
+    "bgs.protocol.channel.v1.Member*\005\010d\020\220N\"\201\005"
+    "\n\014ChannelState\022\023\n\013max_members\030\001 \001(\r\022\023\n\013m"
+    "in_members\030\002 \001(\r\022*\n\tattribute\030\003 \003(\0132\027.bg"
+    "s.protocol.Attribute\022,\n\ninvitation\030\004 \003(\013"
+    "2\030.bgs.protocol.Invitation\022\027\n\017max_invita"
+    "tions\030\005 \001(\r\022\016\n\006reason\030\006 \001(\r\022]\n\rprivacy_l"
+    "evel\030\007 \001(\01622.bgs.protocol.channel.v1.Cha"
+    "nnelState.PrivacyLevel:\022PRIVACY_LEVEL_OP"
+    "EN\022\014\n\004name\030\010 \001(\t\022\025\n\rdelegate_name\030\t \001(\t\022"
+    "\035\n\014channel_type\030\n \001(\t:\007default\022\022\n\007progra"
+    "m\030\013 \001(\007:\0010\022$\n\025allow_offline_members\030\014 \001("
+    "\010:\005false\022#\n\025subscribe_to_presence\030\r \001(\010:"
+    "\004true\022\'\n\030destroy_on_founder_leave\030\016 \001(\010:"
+    "\005false\"\221\001\n\014PrivacyLevel\022\026\n\022PRIVACY_LEVEL"
+    "_OPEN\020\001\022,\n(PRIVACY_LEVEL_OPEN_INVITATION"
+    "_AND_FRIEND\020\002\022!\n\035PRIVACY_LEVEL_OPEN_INVI"
+    "TATION\020\003\022\030\n\024PRIVACY_LEVEL_CLOSED\020\004*\005\010d\020\220"
+    "N\"\270\001\n\013MemberState\022*\n\tattribute\030\001 \003(\0132\027.b"
+    "gs.protocol.Attribute\022\020\n\004role\030\002 \003(\rB\002\020\001\022"
+    "\025\n\nprivileges\030\003 \001(\004:\0010\022\'\n\004info\030\004 \001(\0132\031.b"
+    "gs.protocol.AccountInfo\022$\n\021DEPRECATED_hi"
+    "dden\030\005 \001(\010:\005falseB\002\030\001*\005\010d\020\220N\"g\n\006Member\022("
+    "\n\010identity\030\001 \002(\0132\026.bgs.protocol.Identity"
+    "\0223\n\005state\030\002 \002(\0132$.bgs.protocol.channel.v"
+    "1.MemberStateB\002H\001", 1737);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "channel_types.proto", &protobuf_RegisterTypes);
+  ChannelId::default_instance_ = new ChannelId();
+  Message::default_instance_ = new Message();
+  ListChannelsOptions::default_instance_ = new ListChannelsOptions();
+  ChannelDescription::default_instance_ = new ChannelDescription();
+  ChannelInfo::default_instance_ = new ChannelInfo();
+  ChannelState::_default_channel_type_ =
+      new ::std::string("default", 7);
+  ChannelState::default_instance_ = new ChannelState();
+  MemberState::default_instance_ = new MemberState();
+  Member::default_instance_ = new Member();
+  ChannelId::default_instance_->InitAsDefaultInstance();
+  Message::default_instance_->InitAsDefaultInstance();
+  ListChannelsOptions::default_instance_->InitAsDefaultInstance();
+  ChannelDescription::default_instance_->InitAsDefaultInstance();
+  ChannelInfo::default_instance_->InitAsDefaultInstance();
+  ChannelState::default_instance_->InitAsDefaultInstance();
+  MemberState::default_instance_->InitAsDefaultInstance();
+  Member::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_channel_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_channel_5ftypes_2eproto {
+  StaticDescriptorInitializer_channel_5ftypes_2eproto() {
+    protobuf_AddDesc_channel_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_channel_5ftypes_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ChannelId::kTypeFieldNumber;
+const int ChannelId::kHostFieldNumber;
+const int ChannelId::kIdFieldNumber;
+#endif  // !_MSC_VER
+
+ChannelId::ChannelId()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.ChannelId)
+}
+
+void ChannelId::InitAsDefaultInstance() {
+  host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+}
+
+ChannelId::ChannelId(const ChannelId& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.ChannelId)
+}
+
+void ChannelId::SharedCtor() {
+  _cached_size_ = 0;
+  type_ = 0u;
+  host_ = NULL;
+  id_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ChannelId::~ChannelId() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.ChannelId)
+  SharedDtor();
+}
+
+void ChannelId::SharedDtor() {
+  if (this != default_instance_) {
+    delete host_;
+  }
+}
+
+void ChannelId::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ChannelId::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChannelId_descriptor_;
+}
+
+const ChannelId& ChannelId::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ChannelId* ChannelId::default_instance_ = NULL;
+
+ChannelId* ChannelId::New() const {
+  return new ChannelId;
+}
+
+void ChannelId::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ChannelId*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(type_, id_);
+    if (has_host()) {
+      if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ChannelId::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.ChannelId)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 type = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &type_)));
+          set_has_type();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_host;
+        break;
+      }
+
+      // optional .bgs.protocol.ProcessId host = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_host:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_host()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(29)) goto parse_id;
+        break;
+      }
+
+      // optional fixed32 id = 3;
+      case 3: {
+        if (tag == 29) {
+         parse_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.ChannelId)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.ChannelId)
+  return false;
+#undef DO_
+}
+
+void ChannelId::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.ChannelId)
+  // optional uint32 type = 1;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->type(), output);
+  }
+
+  // optional .bgs.protocol.ProcessId host = 2;
+  if (has_host()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->host(), output);
+  }
+
+  // optional fixed32 id = 3;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.ChannelId)
+}
+
+::google::protobuf::uint8* ChannelId::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.ChannelId)
+  // optional uint32 type = 1;
+  if (has_type()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->type(), target);
+  }
+
+  // optional .bgs.protocol.ProcessId host = 2;
+  if (has_host()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->host(), target);
+  }
+
+  // optional fixed32 id = 3;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.ChannelId)
+  return target;
+}
+
+int ChannelId::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 type = 1;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->type());
+    }
+
+    // optional .bgs.protocol.ProcessId host = 2;
+    if (has_host()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->host());
+    }
+
+    // optional fixed32 id = 3;
+    if (has_id()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ChannelId::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ChannelId* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ChannelId*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ChannelId::MergeFrom(const ChannelId& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_host()) {
+      mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host());
+    }
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ChannelId::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ChannelId::CopyFrom(const ChannelId& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChannelId::IsInitialized() const {
+
+  if (has_host()) {
+    if (!this->host().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ChannelId::Swap(ChannelId* other) {
+  if (other != this) {
+    std::swap(type_, other->type_);
+    std::swap(host_, other->host_);
+    std::swap(id_, other->id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ChannelId::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ChannelId_descriptor_;
+  metadata.reflection = ChannelId_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Message::kAttributeFieldNumber;
+const int Message::kRoleFieldNumber;
+#endif  // !_MSC_VER
+
+Message::Message()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.Message)
+}
+
+void Message::InitAsDefaultInstance() {
+}
+
+Message::Message(const Message& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.Message)
+}
+
+void Message::SharedCtor() {
+  _cached_size_ = 0;
+  role_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Message::~Message() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.Message)
+  SharedDtor();
+}
+
+void Message::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void Message::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Message::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Message_descriptor_;
+}
+
+const Message& Message::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Message* Message::default_instance_ = NULL;
+
+Message* Message::New() const {
+  return new Message;
+}
+
+void Message::Clear() {
+  _extensions_.Clear();
+  role_ = 0u;
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Message::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.Message)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.Attribute attribute = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_attribute;
+        if (input->ExpectTag(16)) goto parse_role;
+        break;
+      }
+
+      // optional uint32 role = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &role_)));
+          set_has_role();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        if ((800u <= tag && tag < 80000u)) {
+          DO_(_extensions_.ParseField(tag, input, default_instance_,
+                                      mutable_unknown_fields()));
+          continue;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.Message)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.Message)
+  return false;
+#undef DO_
+}
+
+void Message::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.Message)
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->attribute(i), output);
+  }
+
+  // optional uint32 role = 2;
+  if (has_role()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->role(), output);
+  }
+
+  // Extension range [100, 10000)
+  _extensions_.SerializeWithCachedSizes(
+      100, 10000, output);
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.Message)
+}
+
+::google::protobuf::uint8* Message::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.Message)
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->attribute(i), target);
+  }
+
+  // optional uint32 role = 2;
+  if (has_role()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->role(), target);
+  }
+
+  // Extension range [100, 10000)
+  target = _extensions_.SerializeWithCachedSizesToArray(
+      100, 10000, target);
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.Message)
+  return target;
+}
+
+int Message::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional uint32 role = 2;
+    if (has_role()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->role());
+    }
+
+  }
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  total_size += _extensions_.ByteSize();
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Message::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Message* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Message*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Message::MergeFrom(const Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_role()) {
+      set_role(from.role());
+    }
+  }
+  _extensions_.MergeFrom(from._extensions_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Message::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Message::CopyFrom(const Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Message::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
+
+  if (!_extensions_.IsInitialized()) return false;  return true;
+}
+
+void Message::Swap(Message* other) {
+  if (other != this) {
+    attribute_.Swap(&other->attribute_);
+    std::swap(role_, other->role_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+    _extensions_.Swap(&other->_extensions_);
+  }
+}
+
+::google::protobuf::Metadata Message::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Message_descriptor_;
+  metadata.reflection = Message_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ListChannelsOptions::kStartIndexFieldNumber;
+const int ListChannelsOptions::kMaxResultsFieldNumber;
+const int ListChannelsOptions::kNameFieldNumber;
+const int ListChannelsOptions::kProgramFieldNumber;
+const int ListChannelsOptions::kLocaleFieldNumber;
+const int ListChannelsOptions::kCapacityFullFieldNumber;
+const int ListChannelsOptions::kAttributeFilterFieldNumber;
+const int ListChannelsOptions::kChannelTypeFieldNumber;
+#endif  // !_MSC_VER
+
+ListChannelsOptions::ListChannelsOptions()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.ListChannelsOptions)
+}
+
+void ListChannelsOptions::InitAsDefaultInstance() {
+  attribute_filter_ = const_cast< ::bgs::protocol::AttributeFilter*>(&::bgs::protocol::AttributeFilter::default_instance());
+}
+
+ListChannelsOptions::ListChannelsOptions(const ListChannelsOptions& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.ListChannelsOptions)
+}
+
+void ListChannelsOptions::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  start_index_ = 0u;
+  max_results_ = 16u;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  program_ = 0u;
+  locale_ = 0u;
+  capacity_full_ = 0u;
+  attribute_filter_ = NULL;
+  channel_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ListChannelsOptions::~ListChannelsOptions() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.ListChannelsOptions)
+  SharedDtor();
+}
+
+void ListChannelsOptions::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (channel_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete channel_type_;
+  }
+  if (this != default_instance_) {
+    delete attribute_filter_;
+  }
+}
+
+void ListChannelsOptions::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ListChannelsOptions::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ListChannelsOptions_descriptor_;
+}
+
+const ListChannelsOptions& ListChannelsOptions::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ListChannelsOptions* ListChannelsOptions::default_instance_ = NULL;
+
+ListChannelsOptions* ListChannelsOptions::New() const {
+  return new ListChannelsOptions;
+}
+
+void ListChannelsOptions::Clear() {
+  _extensions_.Clear();
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ListChannelsOptions*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 255) {
+    ZR_(program_, locale_);
+    start_index_ = 0u;
+    max_results_ = 16u;
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    capacity_full_ = 0u;
+    if (has_attribute_filter()) {
+      if (attribute_filter_ != NULL) attribute_filter_->::bgs::protocol::AttributeFilter::Clear();
+    }
+    if (has_channel_type()) {
+      if (channel_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        channel_type_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ListChannelsOptions::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.ListChannelsOptions)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 start_index = 1 [default = 0];
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &start_index_)));
+          set_has_start_index();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_max_results;
+        break;
+      }
+
+      // optional uint32 max_results = 2 [default = 16];
+      case 2: {
+        if (tag == 16) {
+         parse_max_results:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &max_results_)));
+          set_has_max_results();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_name;
+        break;
+      }
+
+      // optional string name = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(37)) goto parse_program;
+        break;
+      }
+
+      // optional fixed32 program = 4;
+      case 4: {
+        if (tag == 37) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(45)) goto parse_locale;
+        break;
+      }
+
+      // optional fixed32 locale = 5;
+      case 5: {
+        if (tag == 45) {
+         parse_locale:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &locale_)));
+          set_has_locale();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_capacity_full;
+        break;
+      }
+
+      // optional uint32 capacity_full = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_capacity_full:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &capacity_full_)));
+          set_has_capacity_full();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_attribute_filter;
+        break;
+      }
+
+      // required .bgs.protocol.AttributeFilter attribute_filter = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_attribute_filter:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_attribute_filter()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_channel_type;
+        break;
+      }
+
+      // optional string channel_type = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_channel_type:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_channel_type()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->channel_type().data(), this->channel_type().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "channel_type");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        if ((800u <= tag && tag < 80000u)) {
+          DO_(_extensions_.ParseField(tag, input, default_instance_,
+                                      mutable_unknown_fields()));
+          continue;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.ListChannelsOptions)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.ListChannelsOptions)
+  return false;
+#undef DO_
+}
+
+void ListChannelsOptions::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.ListChannelsOptions)
+  // optional uint32 start_index = 1 [default = 0];
+  if (has_start_index()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->start_index(), output);
+  }
+
+  // optional uint32 max_results = 2 [default = 16];
+  if (has_max_results()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->max_results(), output);
+  }
+
+  // optional string name = 3;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->name(), output);
+  }
+
+  // optional fixed32 program = 4;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(4, this->program(), output);
+  }
+
+  // optional fixed32 locale = 5;
+  if (has_locale()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->locale(), output);
+  }
+
+  // optional uint32 capacity_full = 6;
+  if (has_capacity_full()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->capacity_full(), output);
+  }
+
+  // required .bgs.protocol.AttributeFilter attribute_filter = 7;
+  if (has_attribute_filter()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      7, this->attribute_filter(), output);
+  }
+
+  // optional string channel_type = 8;
+  if (has_channel_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->channel_type().data(), this->channel_type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "channel_type");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      8, this->channel_type(), output);
+  }
+
+  // Extension range [100, 10000)
+  _extensions_.SerializeWithCachedSizes(
+      100, 10000, output);
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.ListChannelsOptions)
+}
+
+::google::protobuf::uint8* ListChannelsOptions::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.ListChannelsOptions)
+  // optional uint32 start_index = 1 [default = 0];
+  if (has_start_index()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->start_index(), target);
+  }
+
+  // optional uint32 max_results = 2 [default = 16];
+  if (has_max_results()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->max_results(), target);
+  }
+
+  // optional string name = 3;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->name(), target);
+  }
+
+  // optional fixed32 program = 4;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(4, this->program(), target);
+  }
+
+  // optional fixed32 locale = 5;
+  if (has_locale()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->locale(), target);
+  }
+
+  // optional uint32 capacity_full = 6;
+  if (has_capacity_full()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->capacity_full(), target);
+  }
+
+  // required .bgs.protocol.AttributeFilter attribute_filter = 7;
+  if (has_attribute_filter()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        7, this->attribute_filter(), target);
+  }
+
+  // optional string channel_type = 8;
+  if (has_channel_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->channel_type().data(), this->channel_type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "channel_type");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        8, this->channel_type(), target);
+  }
+
+  // Extension range [100, 10000)
+  target = _extensions_.SerializeWithCachedSizesToArray(
+      100, 10000, target);
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.ListChannelsOptions)
+  return target;
+}
+
+int ListChannelsOptions::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 start_index = 1 [default = 0];
+    if (has_start_index()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->start_index());
+    }
+
+    // optional uint32 max_results = 2 [default = 16];
+    if (has_max_results()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->max_results());
+    }
+
+    // optional string name = 3;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional fixed32 program = 4;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+    // optional fixed32 locale = 5;
+    if (has_locale()) {
+      total_size += 1 + 4;
+    }
+
+    // optional uint32 capacity_full = 6;
+    if (has_capacity_full()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->capacity_full());
+    }
+
+    // required .bgs.protocol.AttributeFilter attribute_filter = 7;
+    if (has_attribute_filter()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->attribute_filter());
+    }
+
+    // optional string channel_type = 8;
+    if (has_channel_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->channel_type());
+    }
+
+  }
+  total_size += _extensions_.ByteSize();
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ListChannelsOptions::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ListChannelsOptions* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ListChannelsOptions*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ListChannelsOptions::MergeFrom(const ListChannelsOptions& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_start_index()) {
+      set_start_index(from.start_index());
+    }
+    if (from.has_max_results()) {
+      set_max_results(from.max_results());
+    }
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_locale()) {
+      set_locale(from.locale());
+    }
+    if (from.has_capacity_full()) {
+      set_capacity_full(from.capacity_full());
+    }
+    if (from.has_attribute_filter()) {
+      mutable_attribute_filter()->::bgs::protocol::AttributeFilter::MergeFrom(from.attribute_filter());
+    }
+    if (from.has_channel_type()) {
+      set_channel_type(from.channel_type());
+    }
+  }
+  _extensions_.MergeFrom(from._extensions_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ListChannelsOptions::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ListChannelsOptions::CopyFrom(const ListChannelsOptions& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ListChannelsOptions::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000040) != 0x00000040) return false;
+
+  if (has_attribute_filter()) {
+    if (!this->attribute_filter().IsInitialized()) return false;
+  }
+
+  if (!_extensions_.IsInitialized()) return false;  return true;
+}
+
+void ListChannelsOptions::Swap(ListChannelsOptions* other) {
+  if (other != this) {
+    std::swap(start_index_, other->start_index_);
+    std::swap(max_results_, other->max_results_);
+    std::swap(name_, other->name_);
+    std::swap(program_, other->program_);
+    std::swap(locale_, other->locale_);
+    std::swap(capacity_full_, other->capacity_full_);
+    std::swap(attribute_filter_, other->attribute_filter_);
+    std::swap(channel_type_, other->channel_type_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+    _extensions_.Swap(&other->_extensions_);
+  }
+}
+
+::google::protobuf::Metadata ListChannelsOptions::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ListChannelsOptions_descriptor_;
+  metadata.reflection = ListChannelsOptions_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ChannelDescription::kChannelIdFieldNumber;
+const int ChannelDescription::kCurrentMembersFieldNumber;
+const int ChannelDescription::kStateFieldNumber;
+#endif  // !_MSC_VER
+
+ChannelDescription::ChannelDescription()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.ChannelDescription)
+}
+
+void ChannelDescription::InitAsDefaultInstance() {
+  channel_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  state_ = const_cast< ::bgs::protocol::channel::v1::ChannelState*>(&::bgs::protocol::channel::v1::ChannelState::default_instance());
+}
+
+ChannelDescription::ChannelDescription(const ChannelDescription& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.ChannelDescription)
+}
+
+void ChannelDescription::SharedCtor() {
+  _cached_size_ = 0;
+  channel_id_ = NULL;
+  current_members_ = 0u;
+  state_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ChannelDescription::~ChannelDescription() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.ChannelDescription)
+  SharedDtor();
+}
+
+void ChannelDescription::SharedDtor() {
+  if (this != default_instance_) {
+    delete channel_id_;
+    delete state_;
+  }
+}
+
+void ChannelDescription::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ChannelDescription::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChannelDescription_descriptor_;
+}
+
+const ChannelDescription& ChannelDescription::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ChannelDescription* ChannelDescription::default_instance_ = NULL;
+
+ChannelDescription* ChannelDescription::New() const {
+  return new ChannelDescription;
+}
+
+void ChannelDescription::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_channel_id()) {
+      if (channel_id_ != NULL) channel_id_->::bgs::protocol::EntityId::Clear();
+    }
+    current_members_ = 0u;
+    if (has_state()) {
+      if (state_ != NULL) state_->::bgs::protocol::channel::v1::ChannelState::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ChannelDescription::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.ChannelDescription)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.EntityId channel_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_channel_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_current_members;
+        break;
+      }
+
+      // optional uint32 current_members = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_current_members:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &current_members_)));
+          set_has_current_members();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_state;
+        break;
+      }
+
+      // optional .bgs.protocol.channel.v1.ChannelState state = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_state:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.ChannelDescription)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.ChannelDescription)
+  return false;
+#undef DO_
+}
+
+void ChannelDescription::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.ChannelDescription)
+  // required .bgs.protocol.EntityId channel_id = 1;
+  if (has_channel_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->channel_id(), output);
+  }
+
+  // optional uint32 current_members = 2;
+  if (has_current_members()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->current_members(), output);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelState state = 3;
+  if (has_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->state(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.ChannelDescription)
+}
+
+::google::protobuf::uint8* ChannelDescription::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.ChannelDescription)
+  // required .bgs.protocol.EntityId channel_id = 1;
+  if (has_channel_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->channel_id(), target);
+  }
+
+  // optional uint32 current_members = 2;
+  if (has_current_members()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->current_members(), target);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelState state = 3;
+  if (has_state()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->state(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.ChannelDescription)
+  return target;
+}
+
+int ChannelDescription::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.EntityId channel_id = 1;
+    if (has_channel_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->channel_id());
+    }
+
+    // optional uint32 current_members = 2;
+    if (has_current_members()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->current_members());
+    }
+
+    // optional .bgs.protocol.channel.v1.ChannelState state = 3;
+    if (has_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->state());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ChannelDescription::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ChannelDescription* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ChannelDescription*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ChannelDescription::MergeFrom(const ChannelDescription& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_channel_id()) {
+      mutable_channel_id()->::bgs::protocol::EntityId::MergeFrom(from.channel_id());
+    }
+    if (from.has_current_members()) {
+      set_current_members(from.current_members());
+    }
+    if (from.has_state()) {
+      mutable_state()->::bgs::protocol::channel::v1::ChannelState::MergeFrom(from.state());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ChannelDescription::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ChannelDescription::CopyFrom(const ChannelDescription& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChannelDescription::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_channel_id()) {
+    if (!this->channel_id().IsInitialized()) return false;
+  }
+  if (has_state()) {
+    if (!this->state().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ChannelDescription::Swap(ChannelDescription* other) {
+  if (other != this) {
+    std::swap(channel_id_, other->channel_id_);
+    std::swap(current_members_, other->current_members_);
+    std::swap(state_, other->state_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ChannelDescription::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ChannelDescription_descriptor_;
+  metadata.reflection = ChannelDescription_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ChannelInfo::kDescriptionFieldNumber;
+const int ChannelInfo::kMemberFieldNumber;
+#endif  // !_MSC_VER
+
+ChannelInfo::ChannelInfo()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.ChannelInfo)
+}
+
+void ChannelInfo::InitAsDefaultInstance() {
+  description_ = const_cast< ::bgs::protocol::channel::v1::ChannelDescription*>(&::bgs::protocol::channel::v1::ChannelDescription::default_instance());
+}
+
+ChannelInfo::ChannelInfo(const ChannelInfo& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.ChannelInfo)
+}
+
+void ChannelInfo::SharedCtor() {
+  _cached_size_ = 0;
+  description_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ChannelInfo::~ChannelInfo() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.ChannelInfo)
+  SharedDtor();
+}
+
+void ChannelInfo::SharedDtor() {
+  if (this != default_instance_) {
+    delete description_;
+  }
+}
+
+void ChannelInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ChannelInfo::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChannelInfo_descriptor_;
+}
+
+const ChannelInfo& ChannelInfo::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ChannelInfo* ChannelInfo::default_instance_ = NULL;
+
+ChannelInfo* ChannelInfo::New() const {
+  return new ChannelInfo;
+}
+
+void ChannelInfo::Clear() {
+  _extensions_.Clear();
+  if (has_description()) {
+    if (description_ != NULL) description_->::bgs::protocol::channel::v1::ChannelDescription::Clear();
+  }
+  member_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ChannelInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.ChannelInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.channel.v1.ChannelDescription description = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_description()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_member;
+        break;
+      }
+
+      // repeated .bgs.protocol.channel.v1.Member member = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_member:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_member()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_member;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        if ((800u <= tag && tag < 80000u)) {
+          DO_(_extensions_.ParseField(tag, input, default_instance_,
+                                      mutable_unknown_fields()));
+          continue;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.ChannelInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.ChannelInfo)
+  return false;
+#undef DO_
+}
+
+void ChannelInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.ChannelInfo)
+  // required .bgs.protocol.channel.v1.ChannelDescription description = 1;
+  if (has_description()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->description(), output);
+  }
+
+  // repeated .bgs.protocol.channel.v1.Member member = 2;
+  for (int i = 0; i < this->member_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->member(i), output);
+  }
+
+  // Extension range [100, 10000)
+  _extensions_.SerializeWithCachedSizes(
+      100, 10000, output);
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.ChannelInfo)
+}
+
+::google::protobuf::uint8* ChannelInfo::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.ChannelInfo)
+  // required .bgs.protocol.channel.v1.ChannelDescription description = 1;
+  if (has_description()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->description(), target);
+  }
+
+  // repeated .bgs.protocol.channel.v1.Member member = 2;
+  for (int i = 0; i < this->member_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->member(i), target);
+  }
+
+  // Extension range [100, 10000)
+  target = _extensions_.SerializeWithCachedSizesToArray(
+      100, 10000, target);
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.ChannelInfo)
+  return target;
+}
+
+int ChannelInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.channel.v1.ChannelDescription description = 1;
+    if (has_description()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->description());
+    }
+
+  }
+  // repeated .bgs.protocol.channel.v1.Member member = 2;
+  total_size += 1 * this->member_size();
+  for (int i = 0; i < this->member_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->member(i));
+  }
+
+  total_size += _extensions_.ByteSize();
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ChannelInfo::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ChannelInfo* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ChannelInfo*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ChannelInfo::MergeFrom(const ChannelInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  member_.MergeFrom(from.member_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_description()) {
+      mutable_description()->::bgs::protocol::channel::v1::ChannelDescription::MergeFrom(from.description());
+    }
+  }
+  _extensions_.MergeFrom(from._extensions_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ChannelInfo::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ChannelInfo::CopyFrom(const ChannelInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChannelInfo::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_description()) {
+    if (!this->description().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->member())) return false;
+
+  if (!_extensions_.IsInitialized()) return false;  return true;
+}
+
+void ChannelInfo::Swap(ChannelInfo* other) {
+  if (other != this) {
+    std::swap(description_, other->description_);
+    member_.Swap(&other->member_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+    _extensions_.Swap(&other->_extensions_);
+  }
+}
+
+::google::protobuf::Metadata ChannelInfo::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ChannelInfo_descriptor_;
+  metadata.reflection = ChannelInfo_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+const ::google::protobuf::EnumDescriptor* ChannelState_PrivacyLevel_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChannelState_PrivacyLevel_descriptor_;
+}
+bool ChannelState_PrivacyLevel_IsValid(int value) {
+  switch(value) {
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const ChannelState_PrivacyLevel ChannelState::PRIVACY_LEVEL_OPEN;
+const ChannelState_PrivacyLevel ChannelState::PRIVACY_LEVEL_OPEN_INVITATION_AND_FRIEND;
+const ChannelState_PrivacyLevel ChannelState::PRIVACY_LEVEL_OPEN_INVITATION;
+const ChannelState_PrivacyLevel ChannelState::PRIVACY_LEVEL_CLOSED;
+const ChannelState_PrivacyLevel ChannelState::PrivacyLevel_MIN;
+const ChannelState_PrivacyLevel ChannelState::PrivacyLevel_MAX;
+const int ChannelState::PrivacyLevel_ARRAYSIZE;
+#endif  // _MSC_VER
+::std::string* ChannelState::_default_channel_type_ = NULL;
+#ifndef _MSC_VER
+const int ChannelState::kMaxMembersFieldNumber;
+const int ChannelState::kMinMembersFieldNumber;
+const int ChannelState::kAttributeFieldNumber;
+const int ChannelState::kInvitationFieldNumber;
+const int ChannelState::kMaxInvitationsFieldNumber;
+const int ChannelState::kReasonFieldNumber;
+const int ChannelState::kPrivacyLevelFieldNumber;
+const int ChannelState::kNameFieldNumber;
+const int ChannelState::kDelegateNameFieldNumber;
+const int ChannelState::kChannelTypeFieldNumber;
+const int ChannelState::kProgramFieldNumber;
+const int ChannelState::kAllowOfflineMembersFieldNumber;
+const int ChannelState::kSubscribeToPresenceFieldNumber;
+const int ChannelState::kDestroyOnFounderLeaveFieldNumber;
+#endif  // !_MSC_VER
+
+ChannelState::ChannelState()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.ChannelState)
+}
+
+void ChannelState::InitAsDefaultInstance() {
+}
+
+ChannelState::ChannelState(const ChannelState& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.ChannelState)
+}
+
+void ChannelState::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  max_members_ = 0u;
+  min_members_ = 0u;
+  max_invitations_ = 0u;
+  reason_ = 0u;
+  privacy_level_ = 1;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  delegate_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  channel_type_ = const_cast< ::std::string*>(_default_channel_type_);
+  program_ = 0u;
+  allow_offline_members_ = false;
+  subscribe_to_presence_ = true;
+  destroy_on_founder_leave_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ChannelState::~ChannelState() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.ChannelState)
+  SharedDtor();
+}
+
+void ChannelState::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (delegate_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete delegate_name_;
+  }
+  if (channel_type_ != _default_channel_type_) {
+    delete channel_type_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ChannelState::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ChannelState::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChannelState_descriptor_;
+}
+
+const ChannelState& ChannelState::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ChannelState* ChannelState::default_instance_ = NULL;
+
+ChannelState* ChannelState::New() const {
+  return new ChannelState;
+}
+
+void ChannelState::Clear() {
+  _extensions_.Clear();
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ChannelState*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 243) {
+    ZR_(max_members_, min_members_);
+    ZR_(max_invitations_, reason_);
+    privacy_level_ = 1;
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+  }
+  if (_has_bits_[8 / 32] & 16128) {
+    if (has_delegate_name()) {
+      if (delegate_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        delegate_name_->clear();
+      }
+    }
+    if (has_channel_type()) {
+      if (channel_type_ != _default_channel_type_) {
+        channel_type_->assign(*_default_channel_type_);
+      }
+    }
+    program_ = 0u;
+    allow_offline_members_ = false;
+    subscribe_to_presence_ = true;
+    destroy_on_founder_leave_ = false;
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  attribute_.Clear();
+  invitation_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ChannelState::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.ChannelState)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 max_members = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &max_members_)));
+          set_has_max_members();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_min_members;
+        break;
+      }
+
+      // optional uint32 min_members = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_min_members:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &min_members_)));
+          set_has_min_members();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.Attribute attribute = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        if (input->ExpectTag(34)) goto parse_invitation;
+        break;
+      }
+
+      // repeated .bgs.protocol.Invitation invitation = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_invitation:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_invitation()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_invitation;
+        if (input->ExpectTag(40)) goto parse_max_invitations;
+        break;
+      }
+
+      // optional uint32 max_invitations = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_max_invitations:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &max_invitations_)));
+          set_has_max_invitations();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_reason;
+        break;
+      }
+
+      // optional uint32 reason = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_reason:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &reason_)));
+          set_has_reason();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_privacy_level;
+        break;
+      }
+
+      // optional .bgs.protocol.channel.v1.ChannelState.PrivacyLevel privacy_level = 7 [default = PRIVACY_LEVEL_OPEN];
+      case 7: {
+        if (tag == 56) {
+         parse_privacy_level:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::channel::v1::ChannelState_PrivacyLevel_IsValid(value)) {
+            set_privacy_level(static_cast< ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(7, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_name;
+        break;
+      }
+
+      // optional string name = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(74)) goto parse_delegate_name;
+        break;
+      }
+
+      // optional string delegate_name = 9;
+      case 9: {
+        if (tag == 74) {
+         parse_delegate_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_delegate_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->delegate_name().data(), this->delegate_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "delegate_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_channel_type;
+        break;
+      }
+
+      // optional string channel_type = 10 [default = "default"];
+      case 10: {
+        if (tag == 82) {
+         parse_channel_type:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_channel_type()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->channel_type().data(), this->channel_type().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "channel_type");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(93)) goto parse_program;
+        break;
+      }
+
+      // optional fixed32 program = 11 [default = 0];
+      case 11: {
+        if (tag == 93) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(96)) goto parse_allow_offline_members;
+        break;
+      }
+
+      // optional bool allow_offline_members = 12 [default = false];
+      case 12: {
+        if (tag == 96) {
+         parse_allow_offline_members:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &allow_offline_members_)));
+          set_has_allow_offline_members();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(104)) goto parse_subscribe_to_presence;
+        break;
+      }
+
+      // optional bool subscribe_to_presence = 13 [default = true];
+      case 13: {
+        if (tag == 104) {
+         parse_subscribe_to_presence:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &subscribe_to_presence_)));
+          set_has_subscribe_to_presence();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(112)) goto parse_destroy_on_founder_leave;
+        break;
+      }
+
+      // optional bool destroy_on_founder_leave = 14 [default = false];
+      case 14: {
+        if (tag == 112) {
+         parse_destroy_on_founder_leave:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &destroy_on_founder_leave_)));
+          set_has_destroy_on_founder_leave();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        if ((800u <= tag && tag < 80000u)) {
+          DO_(_extensions_.ParseField(tag, input, default_instance_,
+                                      mutable_unknown_fields()));
+          continue;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.ChannelState)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.ChannelState)
+  return false;
+#undef DO_
+}
+
+void ChannelState::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.ChannelState)
+  // optional uint32 max_members = 1;
+  if (has_max_members()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->max_members(), output);
+  }
+
+  // optional uint32 min_members = 2;
+  if (has_min_members()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->min_members(), output);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->attribute(i), output);
+  }
+
+  // repeated .bgs.protocol.Invitation invitation = 4;
+  for (int i = 0; i < this->invitation_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->invitation(i), output);
+  }
+
+  // optional uint32 max_invitations = 5;
+  if (has_max_invitations()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->max_invitations(), output);
+  }
+
+  // optional uint32 reason = 6;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->reason(), output);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelState.PrivacyLevel privacy_level = 7 [default = PRIVACY_LEVEL_OPEN];
+  if (has_privacy_level()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      7, this->privacy_level(), output);
+  }
+
+  // optional string name = 8;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      8, this->name(), output);
+  }
+
+  // optional string delegate_name = 9;
+  if (has_delegate_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->delegate_name().data(), this->delegate_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "delegate_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      9, this->delegate_name(), output);
+  }
+
+  // optional string channel_type = 10 [default = "default"];
+  if (has_channel_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->channel_type().data(), this->channel_type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "channel_type");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      10, this->channel_type(), output);
+  }
+
+  // optional fixed32 program = 11 [default = 0];
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(11, this->program(), output);
+  }
+
+  // optional bool allow_offline_members = 12 [default = false];
+  if (has_allow_offline_members()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->allow_offline_members(), output);
+  }
+
+  // optional bool subscribe_to_presence = 13 [default = true];
+  if (has_subscribe_to_presence()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(13, this->subscribe_to_presence(), output);
+  }
+
+  // optional bool destroy_on_founder_leave = 14 [default = false];
+  if (has_destroy_on_founder_leave()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(14, this->destroy_on_founder_leave(), output);
+  }
+
+  // Extension range [100, 10000)
+  _extensions_.SerializeWithCachedSizes(
+      100, 10000, output);
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.ChannelState)
+}
+
+::google::protobuf::uint8* ChannelState::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.ChannelState)
+  // optional uint32 max_members = 1;
+  if (has_max_members()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->max_members(), target);
+  }
+
+  // optional uint32 min_members = 2;
+  if (has_min_members()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->min_members(), target);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->attribute(i), target);
+  }
+
+  // repeated .bgs.protocol.Invitation invitation = 4;
+  for (int i = 0; i < this->invitation_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->invitation(i), target);
+  }
+
+  // optional uint32 max_invitations = 5;
+  if (has_max_invitations()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->max_invitations(), target);
+  }
+
+  // optional uint32 reason = 6;
+  if (has_reason()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->reason(), target);
+  }
+
+  // optional .bgs.protocol.channel.v1.ChannelState.PrivacyLevel privacy_level = 7 [default = PRIVACY_LEVEL_OPEN];
+  if (has_privacy_level()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      7, this->privacy_level(), target);
+  }
+
+  // optional string name = 8;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        8, this->name(), target);
+  }
+
+  // optional string delegate_name = 9;
+  if (has_delegate_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->delegate_name().data(), this->delegate_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "delegate_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        9, this->delegate_name(), target);
+  }
+
+  // optional string channel_type = 10 [default = "default"];
+  if (has_channel_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->channel_type().data(), this->channel_type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "channel_type");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        10, this->channel_type(), target);
+  }
+
+  // optional fixed32 program = 11 [default = 0];
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(11, this->program(), target);
+  }
+
+  // optional bool allow_offline_members = 12 [default = false];
+  if (has_allow_offline_members()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(12, this->allow_offline_members(), target);
+  }
+
+  // optional bool subscribe_to_presence = 13 [default = true];
+  if (has_subscribe_to_presence()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(13, this->subscribe_to_presence(), target);
+  }
+
+  // optional bool destroy_on_founder_leave = 14 [default = false];
+  if (has_destroy_on_founder_leave()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(14, this->destroy_on_founder_leave(), target);
+  }
+
+  // Extension range [100, 10000)
+  target = _extensions_.SerializeWithCachedSizesToArray(
+      100, 10000, target);
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.ChannelState)
+  return target;
+}
+
+int ChannelState::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 max_members = 1;
+    if (has_max_members()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->max_members());
+    }
+
+    // optional uint32 min_members = 2;
+    if (has_min_members()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->min_members());
+    }
+
+    // optional uint32 max_invitations = 5;
+    if (has_max_invitations()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->max_invitations());
+    }
+
+    // optional uint32 reason = 6;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->reason());
+    }
+
+    // optional .bgs.protocol.channel.v1.ChannelState.PrivacyLevel privacy_level = 7 [default = PRIVACY_LEVEL_OPEN];
+    if (has_privacy_level()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->privacy_level());
+    }
+
+    // optional string name = 8;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional string delegate_name = 9;
+    if (has_delegate_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->delegate_name());
+    }
+
+    // optional string channel_type = 10 [default = "default"];
+    if (has_channel_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->channel_type());
+    }
+
+    // optional fixed32 program = 11 [default = 0];
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+    // optional bool allow_offline_members = 12 [default = false];
+    if (has_allow_offline_members()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool subscribe_to_presence = 13 [default = true];
+    if (has_subscribe_to_presence()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool destroy_on_founder_leave = 14 [default = false];
+    if (has_destroy_on_founder_leave()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated .bgs.protocol.Attribute attribute = 3;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  // repeated .bgs.protocol.Invitation invitation = 4;
+  total_size += 1 * this->invitation_size();
+  for (int i = 0; i < this->invitation_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->invitation(i));
+  }
+
+  total_size += _extensions_.ByteSize();
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ChannelState::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ChannelState* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ChannelState*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ChannelState::MergeFrom(const ChannelState& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  invitation_.MergeFrom(from.invitation_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_max_members()) {
+      set_max_members(from.max_members());
+    }
+    if (from.has_min_members()) {
+      set_min_members(from.min_members());
+    }
+    if (from.has_max_invitations()) {
+      set_max_invitations(from.max_invitations());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+    if (from.has_privacy_level()) {
+      set_privacy_level(from.privacy_level());
+    }
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_delegate_name()) {
+      set_delegate_name(from.delegate_name());
+    }
+    if (from.has_channel_type()) {
+      set_channel_type(from.channel_type());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_allow_offline_members()) {
+      set_allow_offline_members(from.allow_offline_members());
+    }
+    if (from.has_subscribe_to_presence()) {
+      set_subscribe_to_presence(from.subscribe_to_presence());
+    }
+    if (from.has_destroy_on_founder_leave()) {
+      set_destroy_on_founder_leave(from.destroy_on_founder_leave());
+    }
+  }
+  _extensions_.MergeFrom(from._extensions_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ChannelState::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ChannelState::CopyFrom(const ChannelState& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChannelState::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->invitation())) return false;
+
+  if (!_extensions_.IsInitialized()) return false;  return true;
+}
+
+void ChannelState::Swap(ChannelState* other) {
+  if (other != this) {
+    std::swap(max_members_, other->max_members_);
+    std::swap(min_members_, other->min_members_);
+    attribute_.Swap(&other->attribute_);
+    invitation_.Swap(&other->invitation_);
+    std::swap(max_invitations_, other->max_invitations_);
+    std::swap(reason_, other->reason_);
+    std::swap(privacy_level_, other->privacy_level_);
+    std::swap(name_, other->name_);
+    std::swap(delegate_name_, other->delegate_name_);
+    std::swap(channel_type_, other->channel_type_);
+    std::swap(program_, other->program_);
+    std::swap(allow_offline_members_, other->allow_offline_members_);
+    std::swap(subscribe_to_presence_, other->subscribe_to_presence_);
+    std::swap(destroy_on_founder_leave_, other->destroy_on_founder_leave_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+    _extensions_.Swap(&other->_extensions_);
+  }
+}
+
+::google::protobuf::Metadata ChannelState::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ChannelState_descriptor_;
+  metadata.reflection = ChannelState_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int MemberState::kAttributeFieldNumber;
+const int MemberState::kRoleFieldNumber;
+const int MemberState::kPrivilegesFieldNumber;
+const int MemberState::kInfoFieldNumber;
+const int MemberState::kDEPRECATEDHiddenFieldNumber;
+#endif  // !_MSC_VER
+
+MemberState::MemberState()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.MemberState)
+}
+
+void MemberState::InitAsDefaultInstance() {
+  info_ = const_cast< ::bgs::protocol::AccountInfo*>(&::bgs::protocol::AccountInfo::default_instance());
+}
+
+MemberState::MemberState(const MemberState& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.MemberState)
+}
+
+void MemberState::SharedCtor() {
+  _cached_size_ = 0;
+  privileges_ = GOOGLE_ULONGLONG(0);
+  info_ = NULL;
+  deprecated_hidden_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+MemberState::~MemberState() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.MemberState)
+  SharedDtor();
+}
+
+void MemberState::SharedDtor() {
+  if (this != default_instance_) {
+    delete info_;
+  }
+}
+
+void MemberState::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* MemberState::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return MemberState_descriptor_;
+}
+
+const MemberState& MemberState::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+MemberState* MemberState::default_instance_ = NULL;
+
+MemberState* MemberState::New() const {
+  return new MemberState;
+}
+
+void MemberState::Clear() {
+  _extensions_.Clear();
+  if (_has_bits_[0 / 32] & 28) {
+    privileges_ = GOOGLE_ULONGLONG(0);
+    if (has_info()) {
+      if (info_ != NULL) info_->::bgs::protocol::AccountInfo::Clear();
+    }
+    deprecated_hidden_ = false;
+  }
+  attribute_.Clear();
+  role_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool MemberState::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.MemberState)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.Attribute attribute = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_attribute;
+        if (input->ExpectTag(18)) goto parse_role;
+        break;
+      }
+
+      // repeated uint32 role = 2 [packed = true];
+      case 2: {
+        if (tag == 18) {
+         parse_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_role())));
+        } else if (tag == 16) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 18, input, this->mutable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_privileges;
+        break;
+      }
+
+      // optional uint64 privileges = 3 [default = 0];
+      case 3: {
+        if (tag == 24) {
+         parse_privileges:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &privileges_)));
+          set_has_privileges();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_info;
+        break;
+      }
+
+      // optional .bgs.protocol.AccountInfo info = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_DEPRECATED_hidden;
+        break;
+      }
+
+      // optional bool DEPRECATED_hidden = 5 [default = false, deprecated = true];
+      case 5: {
+        if (tag == 40) {
+         parse_DEPRECATED_hidden:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &deprecated_hidden_)));
+          set_has_deprecated_hidden();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        if ((800u <= tag && tag < 80000u)) {
+          DO_(_extensions_.ParseField(tag, input, default_instance_,
+                                      mutable_unknown_fields()));
+          continue;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.MemberState)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.MemberState)
+  return false;
+#undef DO_
+}
+
+void MemberState::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.MemberState)
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->attribute(i), output);
+  }
+
+  // repeated uint32 role = 2 [packed = true];
+  if (this->role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->role(i), output);
+  }
+
+  // optional uint64 privileges = 3 [default = 0];
+  if (has_privileges()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->privileges(), output);
+  }
+
+  // optional .bgs.protocol.AccountInfo info = 4;
+  if (has_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->info(), output);
+  }
+
+  // optional bool DEPRECATED_hidden = 5 [default = false, deprecated = true];
+  if (has_deprecated_hidden()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->deprecated_hidden(), output);
+  }
+
+  // Extension range [100, 10000)
+  _extensions_.SerializeWithCachedSizes(
+      100, 10000, output);
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.MemberState)
+}
+
+::google::protobuf::uint8* MemberState::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.MemberState)
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->attribute(i), target);
+  }
+
+  // repeated uint32 role = 2 [packed = true];
+  if (this->role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      2,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->role(i), target);
+  }
+
+  // optional uint64 privileges = 3 [default = 0];
+  if (has_privileges()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->privileges(), target);
+  }
+
+  // optional .bgs.protocol.AccountInfo info = 4;
+  if (has_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->info(), target);
+  }
+
+  // optional bool DEPRECATED_hidden = 5 [default = false, deprecated = true];
+  if (has_deprecated_hidden()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->deprecated_hidden(), target);
+  }
+
+  // Extension range [100, 10000)
+  target = _extensions_.SerializeWithCachedSizesToArray(
+      100, 10000, target);
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.MemberState)
+  return target;
+}
+
+int MemberState::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[2 / 32] & (0xffu << (2 % 32))) {
+    // optional uint64 privileges = 3 [default = 0];
+    if (has_privileges()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->privileges());
+    }
+
+    // optional .bgs.protocol.AccountInfo info = 4;
+    if (has_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->info());
+    }
+
+    // optional bool DEPRECATED_hidden = 5 [default = false, deprecated = true];
+    if (has_deprecated_hidden()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  // repeated uint32 role = 2 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  total_size += _extensions_.ByteSize();
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void MemberState::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const MemberState* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const MemberState*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void MemberState::MergeFrom(const MemberState& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  role_.MergeFrom(from.role_);
+  if (from._has_bits_[2 / 32] & (0xffu << (2 % 32))) {
+    if (from.has_privileges()) {
+      set_privileges(from.privileges());
+    }
+    if (from.has_info()) {
+      mutable_info()->::bgs::protocol::AccountInfo::MergeFrom(from.info());
+    }
+    if (from.has_deprecated_hidden()) {
+      set_deprecated_hidden(from.deprecated_hidden());
+    }
+  }
+  _extensions_.MergeFrom(from._extensions_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void MemberState::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void MemberState::CopyFrom(const MemberState& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool MemberState::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
+  if (has_info()) {
+    if (!this->info().IsInitialized()) return false;
+  }
+
+  if (!_extensions_.IsInitialized()) return false;  return true;
+}
+
+void MemberState::Swap(MemberState* other) {
+  if (other != this) {
+    attribute_.Swap(&other->attribute_);
+    role_.Swap(&other->role_);
+    std::swap(privileges_, other->privileges_);
+    std::swap(info_, other->info_);
+    std::swap(deprecated_hidden_, other->deprecated_hidden_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+    _extensions_.Swap(&other->_extensions_);
+  }
+}
+
+::google::protobuf::Metadata MemberState::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = MemberState_descriptor_;
+  metadata.reflection = MemberState_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Member::kIdentityFieldNumber;
+const int Member::kStateFieldNumber;
+#endif  // !_MSC_VER
+
+Member::Member()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.channel.v1.Member)
+}
+
+void Member::InitAsDefaultInstance() {
+  identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance());
+  state_ = const_cast< ::bgs::protocol::channel::v1::MemberState*>(&::bgs::protocol::channel::v1::MemberState::default_instance());
+}
+
+Member::Member(const Member& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.channel.v1.Member)
+}
+
+void Member::SharedCtor() {
+  _cached_size_ = 0;
+  identity_ = NULL;
+  state_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Member::~Member() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.channel.v1.Member)
+  SharedDtor();
+}
+
+void Member::SharedDtor() {
+  if (this != default_instance_) {
+    delete identity_;
+    delete state_;
+  }
+}
+
+void Member::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Member::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Member_descriptor_;
+}
+
+const Member& Member::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_channel_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Member* Member::default_instance_ = NULL;
+
+Member* Member::New() const {
+  return new Member;
+}
+
+void Member::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_identity()) {
+      if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear();
+    }
+    if (has_state()) {
+      if (state_ != NULL) state_->::bgs::protocol::channel::v1::MemberState::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Member::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.channel.v1.Member)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.Identity identity = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_identity()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_state;
+        break;
+      }
+
+      // required .bgs.protocol.channel.v1.MemberState state = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_state:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_state()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.channel.v1.Member)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.channel.v1.Member)
+  return false;
+#undef DO_
+}
+
+void Member::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.channel.v1.Member)
+  // required .bgs.protocol.Identity identity = 1;
+  if (has_identity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->identity(), output);
+  }
+
+  // required .bgs.protocol.channel.v1.MemberState state = 2;
+  if (has_state()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->state(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.channel.v1.Member)
+}
+
+::google::protobuf::uint8* Member::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.channel.v1.Member)
+  // required .bgs.protocol.Identity identity = 1;
+  if (has_identity()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->identity(), target);
+  }
+
+  // required .bgs.protocol.channel.v1.MemberState state = 2;
+  if (has_state()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->state(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.channel.v1.Member)
+  return target;
+}
+
+int Member::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.Identity identity = 1;
+    if (has_identity()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->identity());
+    }
+
+    // required .bgs.protocol.channel.v1.MemberState state = 2;
+    if (has_state()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->state());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Member::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Member* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Member*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Member::MergeFrom(const Member& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_identity()) {
+      mutable_identity()->::bgs::protocol::Identity::MergeFrom(from.identity());
+    }
+    if (from.has_state()) {
+      mutable_state()->::bgs::protocol::channel::v1::MemberState::MergeFrom(from.state());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Member::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Member::CopyFrom(const Member& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Member::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  if (has_identity()) {
+    if (!this->identity().IsInitialized()) return false;
+  }
+  if (has_state()) {
+    if (!this->state().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void Member::Swap(Member* other) {
+  if (other != this) {
+    std::swap(identity_, other->identity_);
+    std::swap(state_, other->state_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Member::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Member_descriptor_;
+  metadata.reflection = Member_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace channel
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/channel_types.pb.h b/src/server/proto/Client/channel_types.pb.h
new file mode 100644
index 00000000000..a9651e0955b
--- /dev/null
+++ b/src/server/proto/Client/channel_types.pb.h
@@ -0,0 +1,2550 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: channel_types.proto
+
+#ifndef PROTOBUF_channel_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_channel_5ftypes_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/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "attribute_types.pb.h"
+#include "entity_types.pb.h"
+#include "invitation_types.pb.h"
+#include "rpc_types.pb.h"
+#include "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace channel {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto();
+void protobuf_AssignDesc_channel_5ftypes_2eproto();
+void protobuf_ShutdownFile_channel_5ftypes_2eproto();
+
+class ChannelId;
+class Message;
+class ListChannelsOptions;
+class ChannelDescription;
+class ChannelInfo;
+class ChannelState;
+class MemberState;
+class Member;
+
+enum ChannelState_PrivacyLevel {
+  ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN = 1,
+  ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN_INVITATION_AND_FRIEND = 2,
+  ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN_INVITATION = 3,
+  ChannelState_PrivacyLevel_PRIVACY_LEVEL_CLOSED = 4
+};
+TC_SHARED_API bool ChannelState_PrivacyLevel_IsValid(int value);
+const ChannelState_PrivacyLevel ChannelState_PrivacyLevel_PrivacyLevel_MIN = ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN;
+const ChannelState_PrivacyLevel ChannelState_PrivacyLevel_PrivacyLevel_MAX = ChannelState_PrivacyLevel_PRIVACY_LEVEL_CLOSED;
+const int ChannelState_PrivacyLevel_PrivacyLevel_ARRAYSIZE = ChannelState_PrivacyLevel_PrivacyLevel_MAX + 1;
+
+TC_SHARED_API const ::google::protobuf::EnumDescriptor* ChannelState_PrivacyLevel_descriptor();
+inline const ::std::string& ChannelState_PrivacyLevel_Name(ChannelState_PrivacyLevel value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ChannelState_PrivacyLevel_descriptor(), value);
+}
+inline bool ChannelState_PrivacyLevel_Parse(
+    const ::std::string& name, ChannelState_PrivacyLevel* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ChannelState_PrivacyLevel>(
+    ChannelState_PrivacyLevel_descriptor(), name, value);
+}
+// ===================================================================
+
+class TC_SHARED_API ChannelId : public ::google::protobuf::Message {
+ public:
+  ChannelId();
+  virtual ~ChannelId();
+
+  ChannelId(const ChannelId& from);
+
+  inline ChannelId& operator=(const ChannelId& 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 ChannelId& default_instance();
+
+  void Swap(ChannelId* other);
+
+  // implements Message ----------------------------------------------
+
+  ChannelId* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ChannelId& from);
+  void MergeFrom(const ChannelId& 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 type = 1;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 1;
+  inline ::google::protobuf::uint32 type() const;
+  inline void set_type(::google::protobuf::uint32 value);
+
+  // optional .bgs.protocol.ProcessId host = 2;
+  inline bool has_host() const;
+  inline void clear_host();
+  static const int kHostFieldNumber = 2;
+  inline const ::bgs::protocol::ProcessId& host() const;
+  inline ::bgs::protocol::ProcessId* mutable_host();
+  inline ::bgs::protocol::ProcessId* release_host();
+  inline void set_allocated_host(::bgs::protocol::ProcessId* host);
+
+  // optional fixed32 id = 3;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 3;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.ChannelId)
+ private:
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_host();
+  inline void clear_has_host();
+  inline void set_has_id();
+  inline void clear_has_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::ProcessId* host_;
+  ::google::protobuf::uint32 type_;
+  ::google::protobuf::uint32 id_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ChannelId* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API Message : public ::google::protobuf::Message {
+ public:
+  Message();
+  virtual ~Message();
+
+  Message(const Message& from);
+
+  inline Message& operator=(const Message& 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 Message& default_instance();
+
+  void Swap(Message* other);
+
+  // implements Message ----------------------------------------------
+
+  Message* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Message& from);
+  void MergeFrom(const Message& 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.Attribute attribute = 1;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 1;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
+  // optional uint32 role = 2;
+  inline bool has_role() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 2;
+  inline ::google::protobuf::uint32 role() const;
+  inline void set_role(::google::protobuf::uint32 value);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(Message)
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.Message)
+ private:
+  inline void set_has_role();
+  inline void clear_has_role();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
+  ::google::protobuf::uint32 role_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Message* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ListChannelsOptions : public ::google::protobuf::Message {
+ public:
+  ListChannelsOptions();
+  virtual ~ListChannelsOptions();
+
+  ListChannelsOptions(const ListChannelsOptions& from);
+
+  inline ListChannelsOptions& operator=(const ListChannelsOptions& 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 ListChannelsOptions& default_instance();
+
+  void Swap(ListChannelsOptions* other);
+
+  // implements Message ----------------------------------------------
+
+  ListChannelsOptions* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ListChannelsOptions& from);
+  void MergeFrom(const ListChannelsOptions& 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 start_index = 1 [default = 0];
+  inline bool has_start_index() const;
+  inline void clear_start_index();
+  static const int kStartIndexFieldNumber = 1;
+  inline ::google::protobuf::uint32 start_index() const;
+  inline void set_start_index(::google::protobuf::uint32 value);
+
+  // optional uint32 max_results = 2 [default = 16];
+  inline bool has_max_results() const;
+  inline void clear_max_results();
+  static const int kMaxResultsFieldNumber = 2;
+  inline ::google::protobuf::uint32 max_results() const;
+  inline void set_max_results(::google::protobuf::uint32 value);
+
+  // optional string name = 3;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 3;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional fixed32 program = 4;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 4;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // optional fixed32 locale = 5;
+  inline bool has_locale() const;
+  inline void clear_locale();
+  static const int kLocaleFieldNumber = 5;
+  inline ::google::protobuf::uint32 locale() const;
+  inline void set_locale(::google::protobuf::uint32 value);
+
+  // optional uint32 capacity_full = 6;
+  inline bool has_capacity_full() const;
+  inline void clear_capacity_full();
+  static const int kCapacityFullFieldNumber = 6;
+  inline ::google::protobuf::uint32 capacity_full() const;
+  inline void set_capacity_full(::google::protobuf::uint32 value);
+
+  // required .bgs.protocol.AttributeFilter attribute_filter = 7;
+  inline bool has_attribute_filter() const;
+  inline void clear_attribute_filter();
+  static const int kAttributeFilterFieldNumber = 7;
+  inline const ::bgs::protocol::AttributeFilter& attribute_filter() const;
+  inline ::bgs::protocol::AttributeFilter* mutable_attribute_filter();
+  inline ::bgs::protocol::AttributeFilter* release_attribute_filter();
+  inline void set_allocated_attribute_filter(::bgs::protocol::AttributeFilter* attribute_filter);
+
+  // optional string channel_type = 8;
+  inline bool has_channel_type() const;
+  inline void clear_channel_type();
+  static const int kChannelTypeFieldNumber = 8;
+  inline const ::std::string& channel_type() const;
+  inline void set_channel_type(const ::std::string& value);
+  inline void set_channel_type(const char* value);
+  inline void set_channel_type(const char* value, size_t size);
+  inline ::std::string* mutable_channel_type();
+  inline ::std::string* release_channel_type();
+  inline void set_allocated_channel_type(::std::string* channel_type);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ListChannelsOptions)
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.ListChannelsOptions)
+ private:
+  inline void set_has_start_index();
+  inline void clear_has_start_index();
+  inline void set_has_max_results();
+  inline void clear_has_max_results();
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_locale();
+  inline void clear_has_locale();
+  inline void set_has_capacity_full();
+  inline void clear_has_capacity_full();
+  inline void set_has_attribute_filter();
+  inline void clear_has_attribute_filter();
+  inline void set_has_channel_type();
+  inline void clear_has_channel_type();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 start_index_;
+  ::google::protobuf::uint32 max_results_;
+  ::std::string* name_;
+  ::google::protobuf::uint32 program_;
+  ::google::protobuf::uint32 locale_;
+  ::bgs::protocol::AttributeFilter* attribute_filter_;
+  ::std::string* channel_type_;
+  ::google::protobuf::uint32 capacity_full_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ListChannelsOptions* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ChannelDescription : public ::google::protobuf::Message {
+ public:
+  ChannelDescription();
+  virtual ~ChannelDescription();
+
+  ChannelDescription(const ChannelDescription& from);
+
+  inline ChannelDescription& operator=(const ChannelDescription& 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 ChannelDescription& default_instance();
+
+  void Swap(ChannelDescription* other);
+
+  // implements Message ----------------------------------------------
+
+  ChannelDescription* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ChannelDescription& from);
+  void MergeFrom(const ChannelDescription& 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 channel_id = 1;
+  inline bool has_channel_id() const;
+  inline void clear_channel_id();
+  static const int kChannelIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& channel_id() const;
+  inline ::bgs::protocol::EntityId* mutable_channel_id();
+  inline ::bgs::protocol::EntityId* release_channel_id();
+  inline void set_allocated_channel_id(::bgs::protocol::EntityId* channel_id);
+
+  // optional uint32 current_members = 2;
+  inline bool has_current_members() const;
+  inline void clear_current_members();
+  static const int kCurrentMembersFieldNumber = 2;
+  inline ::google::protobuf::uint32 current_members() const;
+  inline void set_current_members(::google::protobuf::uint32 value);
+
+  // optional .bgs.protocol.channel.v1.ChannelState state = 3;
+  inline bool has_state() const;
+  inline void clear_state();
+  static const int kStateFieldNumber = 3;
+  inline const ::bgs::protocol::channel::v1::ChannelState& state() const;
+  inline ::bgs::protocol::channel::v1::ChannelState* mutable_state();
+  inline ::bgs::protocol::channel::v1::ChannelState* release_state();
+  inline void set_allocated_state(::bgs::protocol::channel::v1::ChannelState* state);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.ChannelDescription)
+ private:
+  inline void set_has_channel_id();
+  inline void clear_has_channel_id();
+  inline void set_has_current_members();
+  inline void clear_has_current_members();
+  inline void set_has_state();
+  inline void clear_has_state();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* channel_id_;
+  ::bgs::protocol::channel::v1::ChannelState* state_;
+  ::google::protobuf::uint32 current_members_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ChannelDescription* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ChannelInfo : public ::google::protobuf::Message {
+ public:
+  ChannelInfo();
+  virtual ~ChannelInfo();
+
+  ChannelInfo(const ChannelInfo& from);
+
+  inline ChannelInfo& operator=(const ChannelInfo& 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 ChannelInfo& default_instance();
+
+  void Swap(ChannelInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  ChannelInfo* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ChannelInfo& from);
+  void MergeFrom(const ChannelInfo& 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.channel.v1.ChannelDescription description = 1;
+  inline bool has_description() const;
+  inline void clear_description();
+  static const int kDescriptionFieldNumber = 1;
+  inline const ::bgs::protocol::channel::v1::ChannelDescription& description() const;
+  inline ::bgs::protocol::channel::v1::ChannelDescription* mutable_description();
+  inline ::bgs::protocol::channel::v1::ChannelDescription* release_description();
+  inline void set_allocated_description(::bgs::protocol::channel::v1::ChannelDescription* description);
+
+  // repeated .bgs.protocol.channel.v1.Member member = 2;
+  inline int member_size() const;
+  inline void clear_member();
+  static const int kMemberFieldNumber = 2;
+  inline const ::bgs::protocol::channel::v1::Member& member(int index) const;
+  inline ::bgs::protocol::channel::v1::Member* mutable_member(int index);
+  inline ::bgs::protocol::channel::v1::Member* add_member();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >&
+      member() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >*
+      mutable_member();
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ChannelInfo)
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.ChannelInfo)
+ private:
+  inline void set_has_description();
+  inline void clear_has_description();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::channel::v1::ChannelDescription* description_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member > member_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ChannelInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ChannelState : public ::google::protobuf::Message {
+ public:
+  ChannelState();
+  virtual ~ChannelState();
+
+  ChannelState(const ChannelState& from);
+
+  inline ChannelState& operator=(const ChannelState& 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 ChannelState& default_instance();
+
+  void Swap(ChannelState* other);
+
+  // implements Message ----------------------------------------------
+
+  ChannelState* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ChannelState& from);
+  void MergeFrom(const ChannelState& 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 ----------------------------------------------------
+
+  typedef ChannelState_PrivacyLevel PrivacyLevel;
+  static const PrivacyLevel PRIVACY_LEVEL_OPEN = ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN;
+  static const PrivacyLevel PRIVACY_LEVEL_OPEN_INVITATION_AND_FRIEND = ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN_INVITATION_AND_FRIEND;
+  static const PrivacyLevel PRIVACY_LEVEL_OPEN_INVITATION = ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN_INVITATION;
+  static const PrivacyLevel PRIVACY_LEVEL_CLOSED = ChannelState_PrivacyLevel_PRIVACY_LEVEL_CLOSED;
+  static inline bool PrivacyLevel_IsValid(int value) {
+    return ChannelState_PrivacyLevel_IsValid(value);
+  }
+  static const PrivacyLevel PrivacyLevel_MIN =
+    ChannelState_PrivacyLevel_PrivacyLevel_MIN;
+  static const PrivacyLevel PrivacyLevel_MAX =
+    ChannelState_PrivacyLevel_PrivacyLevel_MAX;
+  static const int PrivacyLevel_ARRAYSIZE =
+    ChannelState_PrivacyLevel_PrivacyLevel_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  PrivacyLevel_descriptor() {
+    return ChannelState_PrivacyLevel_descriptor();
+  }
+  static inline const ::std::string& PrivacyLevel_Name(PrivacyLevel value) {
+    return ChannelState_PrivacyLevel_Name(value);
+  }
+  static inline bool PrivacyLevel_Parse(const ::std::string& name,
+      PrivacyLevel* value) {
+    return ChannelState_PrivacyLevel_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  // optional uint32 max_members = 1;
+  inline bool has_max_members() const;
+  inline void clear_max_members();
+  static const int kMaxMembersFieldNumber = 1;
+  inline ::google::protobuf::uint32 max_members() const;
+  inline void set_max_members(::google::protobuf::uint32 value);
+
+  // optional uint32 min_members = 2;
+  inline bool has_min_members() const;
+  inline void clear_min_members();
+  static const int kMinMembersFieldNumber = 2;
+  inline ::google::protobuf::uint32 min_members() const;
+  inline void set_min_members(::google::protobuf::uint32 value);
+
+  // repeated .bgs.protocol.Attribute attribute = 3;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 3;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
+  // repeated .bgs.protocol.Invitation invitation = 4;
+  inline int invitation_size() const;
+  inline void clear_invitation();
+  static const int kInvitationFieldNumber = 4;
+  inline const ::bgs::protocol::Invitation& invitation(int index) const;
+  inline ::bgs::protocol::Invitation* mutable_invitation(int index);
+  inline ::bgs::protocol::Invitation* add_invitation();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >&
+      invitation() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >*
+      mutable_invitation();
+
+  // optional uint32 max_invitations = 5;
+  inline bool has_max_invitations() const;
+  inline void clear_max_invitations();
+  static const int kMaxInvitationsFieldNumber = 5;
+  inline ::google::protobuf::uint32 max_invitations() const;
+  inline void set_max_invitations(::google::protobuf::uint32 value);
+
+  // optional uint32 reason = 6;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 6;
+  inline ::google::protobuf::uint32 reason() const;
+  inline void set_reason(::google::protobuf::uint32 value);
+
+  // optional .bgs.protocol.channel.v1.ChannelState.PrivacyLevel privacy_level = 7 [default = PRIVACY_LEVEL_OPEN];
+  inline bool has_privacy_level() const;
+  inline void clear_privacy_level();
+  static const int kPrivacyLevelFieldNumber = 7;
+  inline ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel privacy_level() const;
+  inline void set_privacy_level(::bgs::protocol::channel::v1::ChannelState_PrivacyLevel value);
+
+  // optional string name = 8;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 8;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // optional string delegate_name = 9;
+  inline bool has_delegate_name() const;
+  inline void clear_delegate_name();
+  static const int kDelegateNameFieldNumber = 9;
+  inline const ::std::string& delegate_name() const;
+  inline void set_delegate_name(const ::std::string& value);
+  inline void set_delegate_name(const char* value);
+  inline void set_delegate_name(const char* value, size_t size);
+  inline ::std::string* mutable_delegate_name();
+  inline ::std::string* release_delegate_name();
+  inline void set_allocated_delegate_name(::std::string* delegate_name);
+
+  // optional string channel_type = 10 [default = "default"];
+  inline bool has_channel_type() const;
+  inline void clear_channel_type();
+  static const int kChannelTypeFieldNumber = 10;
+  inline const ::std::string& channel_type() const;
+  inline void set_channel_type(const ::std::string& value);
+  inline void set_channel_type(const char* value);
+  inline void set_channel_type(const char* value, size_t size);
+  inline ::std::string* mutable_channel_type();
+  inline ::std::string* release_channel_type();
+  inline void set_allocated_channel_type(::std::string* channel_type);
+
+  // optional fixed32 program = 11 [default = 0];
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 11;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // optional bool allow_offline_members = 12 [default = false];
+  inline bool has_allow_offline_members() const;
+  inline void clear_allow_offline_members();
+  static const int kAllowOfflineMembersFieldNumber = 12;
+  inline bool allow_offline_members() const;
+  inline void set_allow_offline_members(bool value);
+
+  // optional bool subscribe_to_presence = 13 [default = true];
+  inline bool has_subscribe_to_presence() const;
+  inline void clear_subscribe_to_presence();
+  static const int kSubscribeToPresenceFieldNumber = 13;
+  inline bool subscribe_to_presence() const;
+  inline void set_subscribe_to_presence(bool value);
+
+  // optional bool destroy_on_founder_leave = 14 [default = false];
+  inline bool has_destroy_on_founder_leave() const;
+  inline void clear_destroy_on_founder_leave();
+  static const int kDestroyOnFounderLeaveFieldNumber = 14;
+  inline bool destroy_on_founder_leave() const;
+  inline void set_destroy_on_founder_leave(bool value);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ChannelState)
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.ChannelState)
+ private:
+  inline void set_has_max_members();
+  inline void clear_has_max_members();
+  inline void set_has_min_members();
+  inline void clear_has_min_members();
+  inline void set_has_max_invitations();
+  inline void clear_has_max_invitations();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+  inline void set_has_privacy_level();
+  inline void clear_has_privacy_level();
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_delegate_name();
+  inline void clear_has_delegate_name();
+  inline void set_has_channel_type();
+  inline void clear_has_channel_type();
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_allow_offline_members();
+  inline void clear_has_allow_offline_members();
+  inline void set_has_subscribe_to_presence();
+  inline void clear_has_subscribe_to_presence();
+  inline void set_has_destroy_on_founder_leave();
+  inline void clear_has_destroy_on_founder_leave();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 max_members_;
+  ::google::protobuf::uint32 min_members_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation > invitation_;
+  ::google::protobuf::uint32 max_invitations_;
+  ::google::protobuf::uint32 reason_;
+  ::std::string* name_;
+  ::std::string* delegate_name_;
+  int privacy_level_;
+  ::google::protobuf::uint32 program_;
+  static ::std::string* _default_channel_type_;
+  ::std::string* channel_type_;
+  bool allow_offline_members_;
+  bool subscribe_to_presence_;
+  bool destroy_on_founder_leave_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ChannelState* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API MemberState : public ::google::protobuf::Message {
+ public:
+  MemberState();
+  virtual ~MemberState();
+
+  MemberState(const MemberState& from);
+
+  inline MemberState& operator=(const MemberState& 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 MemberState& default_instance();
+
+  void Swap(MemberState* other);
+
+  // implements Message ----------------------------------------------
+
+  MemberState* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const MemberState& from);
+  void MergeFrom(const MemberState& 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.Attribute attribute = 1;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 1;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
+  // repeated uint32 role = 2 [packed = true];
+  inline int role_size() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 2;
+  inline ::google::protobuf::uint32 role(int index) const;
+  inline void set_role(int index, ::google::protobuf::uint32 value);
+  inline void add_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_role();
+
+  // optional uint64 privileges = 3 [default = 0];
+  inline bool has_privileges() const;
+  inline void clear_privileges();
+  static const int kPrivilegesFieldNumber = 3;
+  inline ::google::protobuf::uint64 privileges() const;
+  inline void set_privileges(::google::protobuf::uint64 value);
+
+  // optional .bgs.protocol.AccountInfo info = 4;
+  inline bool has_info() const;
+  inline void clear_info();
+  static const int kInfoFieldNumber = 4;
+  inline const ::bgs::protocol::AccountInfo& info() const;
+  inline ::bgs::protocol::AccountInfo* mutable_info();
+  inline ::bgs::protocol::AccountInfo* release_info();
+  inline void set_allocated_info(::bgs::protocol::AccountInfo* info);
+
+  // optional bool DEPRECATED_hidden = 5 [default = false, deprecated = true];
+  inline bool has_deprecated_hidden() const PROTOBUF_DEPRECATED;
+  inline void clear_deprecated_hidden() PROTOBUF_DEPRECATED;
+  static const int kDEPRECATEDHiddenFieldNumber = 5;
+  inline bool deprecated_hidden() const PROTOBUF_DEPRECATED;
+  inline void set_deprecated_hidden(bool value) PROTOBUF_DEPRECATED;
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(MemberState)
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.MemberState)
+ private:
+  inline void set_has_privileges();
+  inline void clear_has_privileges();
+  inline void set_has_info();
+  inline void clear_has_info();
+  inline void set_has_deprecated_hidden();
+  inline void clear_has_deprecated_hidden();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
+  mutable int _role_cached_byte_size_;
+  ::google::protobuf::uint64 privileges_;
+  ::bgs::protocol::AccountInfo* info_;
+  bool deprecated_hidden_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static MemberState* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API Member : public ::google::protobuf::Message {
+ public:
+  Member();
+  virtual ~Member();
+
+  Member(const Member& from);
+
+  inline Member& operator=(const Member& 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 Member& default_instance();
+
+  void Swap(Member* other);
+
+  // implements Message ----------------------------------------------
+
+  Member* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Member& from);
+  void MergeFrom(const Member& 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.Identity identity = 1;
+  inline bool has_identity() const;
+  inline void clear_identity();
+  static const int kIdentityFieldNumber = 1;
+  inline const ::bgs::protocol::Identity& identity() const;
+  inline ::bgs::protocol::Identity* mutable_identity();
+  inline ::bgs::protocol::Identity* release_identity();
+  inline void set_allocated_identity(::bgs::protocol::Identity* identity);
+
+  // required .bgs.protocol.channel.v1.MemberState state = 2;
+  inline bool has_state() const;
+  inline void clear_state();
+  static const int kStateFieldNumber = 2;
+  inline const ::bgs::protocol::channel::v1::MemberState& state() const;
+  inline ::bgs::protocol::channel::v1::MemberState* mutable_state();
+  inline ::bgs::protocol::channel::v1::MemberState* release_state();
+  inline void set_allocated_state(::bgs::protocol::channel::v1::MemberState* state);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.Member)
+ private:
+  inline void set_has_identity();
+  inline void clear_has_identity();
+  inline void set_has_state();
+  inline void clear_has_state();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::Identity* identity_;
+  ::bgs::protocol::channel::v1::MemberState* state_;
+  friend void TC_SHARED_API protobuf_AddDesc_channel_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Member* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// ChannelId
+
+// optional uint32 type = 1;
+inline bool ChannelId::has_type() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ChannelId::set_has_type() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ChannelId::clear_has_type() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ChannelId::clear_type() {
+  type_ = 0u;
+  clear_has_type();
+}
+inline ::google::protobuf::uint32 ChannelId::type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelId.type)
+  return type_;
+}
+inline void ChannelId::set_type(::google::protobuf::uint32 value) {
+  set_has_type();
+  type_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelId.type)
+}
+
+// optional .bgs.protocol.ProcessId host = 2;
+inline bool ChannelId::has_host() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ChannelId::set_has_host() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ChannelId::clear_has_host() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ChannelId::clear_host() {
+  if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+  clear_has_host();
+}
+inline const ::bgs::protocol::ProcessId& ChannelId::host() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelId.host)
+  return host_ != NULL ? *host_ : *default_instance_->host_;
+}
+inline ::bgs::protocol::ProcessId* ChannelId::mutable_host() {
+  set_has_host();
+  if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelId.host)
+  return host_;
+}
+inline ::bgs::protocol::ProcessId* ChannelId::release_host() {
+  clear_has_host();
+  ::bgs::protocol::ProcessId* temp = host_;
+  host_ = NULL;
+  return temp;
+}
+inline void ChannelId::set_allocated_host(::bgs::protocol::ProcessId* host) {
+  delete host_;
+  host_ = host;
+  if (host) {
+    set_has_host();
+  } else {
+    clear_has_host();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelId.host)
+}
+
+// optional fixed32 id = 3;
+inline bool ChannelId::has_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ChannelId::set_has_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ChannelId::clear_has_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ChannelId::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 ChannelId::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelId.id)
+  return id_;
+}
+inline void ChannelId::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelId.id)
+}
+
+// -------------------------------------------------------------------
+
+// Message
+
+// repeated .bgs.protocol.Attribute attribute = 1;
+inline int Message::attribute_size() const {
+  return attribute_.size();
+}
+inline void Message::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::Attribute& Message::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.Message.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::Attribute* Message::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.Message.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* Message::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.Message.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+Message::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.Message.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+Message::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.Message.attribute)
+  return &attribute_;
+}
+
+// optional uint32 role = 2;
+inline bool Message::has_role() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Message::set_has_role() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Message::clear_has_role() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Message::clear_role() {
+  role_ = 0u;
+  clear_has_role();
+}
+inline ::google::protobuf::uint32 Message::role() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.Message.role)
+  return role_;
+}
+inline void Message::set_role(::google::protobuf::uint32 value) {
+  set_has_role();
+  role_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.Message.role)
+}
+
+// -------------------------------------------------------------------
+
+// ListChannelsOptions
+
+// optional uint32 start_index = 1 [default = 0];
+inline bool ListChannelsOptions::has_start_index() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ListChannelsOptions::set_has_start_index() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ListChannelsOptions::clear_has_start_index() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ListChannelsOptions::clear_start_index() {
+  start_index_ = 0u;
+  clear_has_start_index();
+}
+inline ::google::protobuf::uint32 ListChannelsOptions::start_index() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.start_index)
+  return start_index_;
+}
+inline void ListChannelsOptions::set_start_index(::google::protobuf::uint32 value) {
+  set_has_start_index();
+  start_index_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.start_index)
+}
+
+// optional uint32 max_results = 2 [default = 16];
+inline bool ListChannelsOptions::has_max_results() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ListChannelsOptions::set_has_max_results() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ListChannelsOptions::clear_has_max_results() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ListChannelsOptions::clear_max_results() {
+  max_results_ = 16u;
+  clear_has_max_results();
+}
+inline ::google::protobuf::uint32 ListChannelsOptions::max_results() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.max_results)
+  return max_results_;
+}
+inline void ListChannelsOptions::set_max_results(::google::protobuf::uint32 value) {
+  set_has_max_results();
+  max_results_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.max_results)
+}
+
+// optional string name = 3;
+inline bool ListChannelsOptions::has_name() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ListChannelsOptions::set_has_name() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ListChannelsOptions::clear_has_name() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ListChannelsOptions::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& ListChannelsOptions::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.name)
+  return *name_;
+}
+inline void ListChannelsOptions::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.name)
+}
+inline void ListChannelsOptions::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.ListChannelsOptions.name)
+}
+inline void ListChannelsOptions::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.ListChannelsOptions.name)
+}
+inline ::std::string* ListChannelsOptions::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ListChannelsOptions.name)
+  return name_;
+}
+inline ::std::string* ListChannelsOptions::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ListChannelsOptions::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ListChannelsOptions.name)
+}
+
+// optional fixed32 program = 4;
+inline bool ListChannelsOptions::has_program() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ListChannelsOptions::set_has_program() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ListChannelsOptions::clear_has_program() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ListChannelsOptions::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 ListChannelsOptions::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.program)
+  return program_;
+}
+inline void ListChannelsOptions::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.program)
+}
+
+// optional fixed32 locale = 5;
+inline bool ListChannelsOptions::has_locale() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ListChannelsOptions::set_has_locale() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ListChannelsOptions::clear_has_locale() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ListChannelsOptions::clear_locale() {
+  locale_ = 0u;
+  clear_has_locale();
+}
+inline ::google::protobuf::uint32 ListChannelsOptions::locale() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.locale)
+  return locale_;
+}
+inline void ListChannelsOptions::set_locale(::google::protobuf::uint32 value) {
+  set_has_locale();
+  locale_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.locale)
+}
+
+// optional uint32 capacity_full = 6;
+inline bool ListChannelsOptions::has_capacity_full() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ListChannelsOptions::set_has_capacity_full() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ListChannelsOptions::clear_has_capacity_full() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ListChannelsOptions::clear_capacity_full() {
+  capacity_full_ = 0u;
+  clear_has_capacity_full();
+}
+inline ::google::protobuf::uint32 ListChannelsOptions::capacity_full() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.capacity_full)
+  return capacity_full_;
+}
+inline void ListChannelsOptions::set_capacity_full(::google::protobuf::uint32 value) {
+  set_has_capacity_full();
+  capacity_full_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.capacity_full)
+}
+
+// required .bgs.protocol.AttributeFilter attribute_filter = 7;
+inline bool ListChannelsOptions::has_attribute_filter() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ListChannelsOptions::set_has_attribute_filter() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ListChannelsOptions::clear_has_attribute_filter() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ListChannelsOptions::clear_attribute_filter() {
+  if (attribute_filter_ != NULL) attribute_filter_->::bgs::protocol::AttributeFilter::Clear();
+  clear_has_attribute_filter();
+}
+inline const ::bgs::protocol::AttributeFilter& ListChannelsOptions::attribute_filter() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.attribute_filter)
+  return attribute_filter_ != NULL ? *attribute_filter_ : *default_instance_->attribute_filter_;
+}
+inline ::bgs::protocol::AttributeFilter* ListChannelsOptions::mutable_attribute_filter() {
+  set_has_attribute_filter();
+  if (attribute_filter_ == NULL) attribute_filter_ = new ::bgs::protocol::AttributeFilter;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ListChannelsOptions.attribute_filter)
+  return attribute_filter_;
+}
+inline ::bgs::protocol::AttributeFilter* ListChannelsOptions::release_attribute_filter() {
+  clear_has_attribute_filter();
+  ::bgs::protocol::AttributeFilter* temp = attribute_filter_;
+  attribute_filter_ = NULL;
+  return temp;
+}
+inline void ListChannelsOptions::set_allocated_attribute_filter(::bgs::protocol::AttributeFilter* attribute_filter) {
+  delete attribute_filter_;
+  attribute_filter_ = attribute_filter;
+  if (attribute_filter) {
+    set_has_attribute_filter();
+  } else {
+    clear_has_attribute_filter();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ListChannelsOptions.attribute_filter)
+}
+
+// optional string channel_type = 8;
+inline bool ListChannelsOptions::has_channel_type() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ListChannelsOptions::set_has_channel_type() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ListChannelsOptions::clear_has_channel_type() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ListChannelsOptions::clear_channel_type() {
+  if (channel_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    channel_type_->clear();
+  }
+  clear_has_channel_type();
+}
+inline const ::std::string& ListChannelsOptions::channel_type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.channel_type)
+  return *channel_type_;
+}
+inline void ListChannelsOptions::set_channel_type(const ::std::string& value) {
+  set_has_channel_type();
+  if (channel_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    channel_type_ = new ::std::string;
+  }
+  channel_type_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.channel_type)
+}
+inline void ListChannelsOptions::set_channel_type(const char* value) {
+  set_has_channel_type();
+  if (channel_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    channel_type_ = new ::std::string;
+  }
+  channel_type_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.ListChannelsOptions.channel_type)
+}
+inline void ListChannelsOptions::set_channel_type(const char* value, size_t size) {
+  set_has_channel_type();
+  if (channel_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    channel_type_ = new ::std::string;
+  }
+  channel_type_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.ListChannelsOptions.channel_type)
+}
+inline ::std::string* ListChannelsOptions::mutable_channel_type() {
+  set_has_channel_type();
+  if (channel_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    channel_type_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ListChannelsOptions.channel_type)
+  return channel_type_;
+}
+inline ::std::string* ListChannelsOptions::release_channel_type() {
+  clear_has_channel_type();
+  if (channel_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = channel_type_;
+    channel_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ListChannelsOptions::set_allocated_channel_type(::std::string* channel_type) {
+  if (channel_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete channel_type_;
+  }
+  if (channel_type) {
+    set_has_channel_type();
+    channel_type_ = channel_type;
+  } else {
+    clear_has_channel_type();
+    channel_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ListChannelsOptions.channel_type)
+}
+
+// -------------------------------------------------------------------
+
+// ChannelDescription
+
+// required .bgs.protocol.EntityId channel_id = 1;
+inline bool ChannelDescription::has_channel_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ChannelDescription::set_has_channel_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ChannelDescription::clear_has_channel_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ChannelDescription::clear_channel_id() {
+  if (channel_id_ != NULL) channel_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_channel_id();
+}
+inline const ::bgs::protocol::EntityId& ChannelDescription::channel_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelDescription.channel_id)
+  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
+}
+inline ::bgs::protocol::EntityId* ChannelDescription::mutable_channel_id() {
+  set_has_channel_id();
+  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelDescription.channel_id)
+  return channel_id_;
+}
+inline ::bgs::protocol::EntityId* ChannelDescription::release_channel_id() {
+  clear_has_channel_id();
+  ::bgs::protocol::EntityId* temp = channel_id_;
+  channel_id_ = NULL;
+  return temp;
+}
+inline void ChannelDescription::set_allocated_channel_id(::bgs::protocol::EntityId* channel_id) {
+  delete channel_id_;
+  channel_id_ = channel_id;
+  if (channel_id) {
+    set_has_channel_id();
+  } else {
+    clear_has_channel_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelDescription.channel_id)
+}
+
+// optional uint32 current_members = 2;
+inline bool ChannelDescription::has_current_members() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ChannelDescription::set_has_current_members() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ChannelDescription::clear_has_current_members() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ChannelDescription::clear_current_members() {
+  current_members_ = 0u;
+  clear_has_current_members();
+}
+inline ::google::protobuf::uint32 ChannelDescription::current_members() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelDescription.current_members)
+  return current_members_;
+}
+inline void ChannelDescription::set_current_members(::google::protobuf::uint32 value) {
+  set_has_current_members();
+  current_members_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelDescription.current_members)
+}
+
+// optional .bgs.protocol.channel.v1.ChannelState state = 3;
+inline bool ChannelDescription::has_state() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ChannelDescription::set_has_state() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ChannelDescription::clear_has_state() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ChannelDescription::clear_state() {
+  if (state_ != NULL) state_->::bgs::protocol::channel::v1::ChannelState::Clear();
+  clear_has_state();
+}
+inline const ::bgs::protocol::channel::v1::ChannelState& ChannelDescription::state() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelDescription.state)
+  return state_ != NULL ? *state_ : *default_instance_->state_;
+}
+inline ::bgs::protocol::channel::v1::ChannelState* ChannelDescription::mutable_state() {
+  set_has_state();
+  if (state_ == NULL) state_ = new ::bgs::protocol::channel::v1::ChannelState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelDescription.state)
+  return state_;
+}
+inline ::bgs::protocol::channel::v1::ChannelState* ChannelDescription::release_state() {
+  clear_has_state();
+  ::bgs::protocol::channel::v1::ChannelState* temp = state_;
+  state_ = NULL;
+  return temp;
+}
+inline void ChannelDescription::set_allocated_state(::bgs::protocol::channel::v1::ChannelState* state) {
+  delete state_;
+  state_ = state;
+  if (state) {
+    set_has_state();
+  } else {
+    clear_has_state();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelDescription.state)
+}
+
+// -------------------------------------------------------------------
+
+// ChannelInfo
+
+// required .bgs.protocol.channel.v1.ChannelDescription description = 1;
+inline bool ChannelInfo::has_description() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ChannelInfo::set_has_description() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ChannelInfo::clear_has_description() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ChannelInfo::clear_description() {
+  if (description_ != NULL) description_->::bgs::protocol::channel::v1::ChannelDescription::Clear();
+  clear_has_description();
+}
+inline const ::bgs::protocol::channel::v1::ChannelDescription& ChannelInfo::description() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelInfo.description)
+  return description_ != NULL ? *description_ : *default_instance_->description_;
+}
+inline ::bgs::protocol::channel::v1::ChannelDescription* ChannelInfo::mutable_description() {
+  set_has_description();
+  if (description_ == NULL) description_ = new ::bgs::protocol::channel::v1::ChannelDescription;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelInfo.description)
+  return description_;
+}
+inline ::bgs::protocol::channel::v1::ChannelDescription* ChannelInfo::release_description() {
+  clear_has_description();
+  ::bgs::protocol::channel::v1::ChannelDescription* temp = description_;
+  description_ = NULL;
+  return temp;
+}
+inline void ChannelInfo::set_allocated_description(::bgs::protocol::channel::v1::ChannelDescription* description) {
+  delete description_;
+  description_ = description;
+  if (description) {
+    set_has_description();
+  } else {
+    clear_has_description();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelInfo.description)
+}
+
+// repeated .bgs.protocol.channel.v1.Member member = 2;
+inline int ChannelInfo::member_size() const {
+  return member_.size();
+}
+inline void ChannelInfo::clear_member() {
+  member_.Clear();
+}
+inline const ::bgs::protocol::channel::v1::Member& ChannelInfo::member(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelInfo.member)
+  return member_.Get(index);
+}
+inline ::bgs::protocol::channel::v1::Member* ChannelInfo::mutable_member(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelInfo.member)
+  return member_.Mutable(index);
+}
+inline ::bgs::protocol::channel::v1::Member* ChannelInfo::add_member() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.ChannelInfo.member)
+  return member_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >&
+ChannelInfo::member() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.ChannelInfo.member)
+  return member_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >*
+ChannelInfo::mutable_member() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.ChannelInfo.member)
+  return &member_;
+}
+
+// -------------------------------------------------------------------
+
+// ChannelState
+
+// optional uint32 max_members = 1;
+inline bool ChannelState::has_max_members() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ChannelState::set_has_max_members() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ChannelState::clear_has_max_members() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ChannelState::clear_max_members() {
+  max_members_ = 0u;
+  clear_has_max_members();
+}
+inline ::google::protobuf::uint32 ChannelState::max_members() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.max_members)
+  return max_members_;
+}
+inline void ChannelState::set_max_members(::google::protobuf::uint32 value) {
+  set_has_max_members();
+  max_members_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.max_members)
+}
+
+// optional uint32 min_members = 2;
+inline bool ChannelState::has_min_members() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ChannelState::set_has_min_members() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ChannelState::clear_has_min_members() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ChannelState::clear_min_members() {
+  min_members_ = 0u;
+  clear_has_min_members();
+}
+inline ::google::protobuf::uint32 ChannelState::min_members() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.min_members)
+  return min_members_;
+}
+inline void ChannelState::set_min_members(::google::protobuf::uint32 value) {
+  set_has_min_members();
+  min_members_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.min_members)
+}
+
+// repeated .bgs.protocol.Attribute attribute = 3;
+inline int ChannelState::attribute_size() const {
+  return attribute_.size();
+}
+inline void ChannelState::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::Attribute& ChannelState::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::Attribute* ChannelState::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelState.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* ChannelState::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.ChannelState.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+ChannelState::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.ChannelState.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+ChannelState::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.ChannelState.attribute)
+  return &attribute_;
+}
+
+// repeated .bgs.protocol.Invitation invitation = 4;
+inline int ChannelState::invitation_size() const {
+  return invitation_.size();
+}
+inline void ChannelState::clear_invitation() {
+  invitation_.Clear();
+}
+inline const ::bgs::protocol::Invitation& ChannelState::invitation(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.invitation)
+  return invitation_.Get(index);
+}
+inline ::bgs::protocol::Invitation* ChannelState::mutable_invitation(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelState.invitation)
+  return invitation_.Mutable(index);
+}
+inline ::bgs::protocol::Invitation* ChannelState::add_invitation() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.ChannelState.invitation)
+  return invitation_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >&
+ChannelState::invitation() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.ChannelState.invitation)
+  return invitation_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >*
+ChannelState::mutable_invitation() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.ChannelState.invitation)
+  return &invitation_;
+}
+
+// optional uint32 max_invitations = 5;
+inline bool ChannelState::has_max_invitations() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ChannelState::set_has_max_invitations() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ChannelState::clear_has_max_invitations() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ChannelState::clear_max_invitations() {
+  max_invitations_ = 0u;
+  clear_has_max_invitations();
+}
+inline ::google::protobuf::uint32 ChannelState::max_invitations() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.max_invitations)
+  return max_invitations_;
+}
+inline void ChannelState::set_max_invitations(::google::protobuf::uint32 value) {
+  set_has_max_invitations();
+  max_invitations_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.max_invitations)
+}
+
+// optional uint32 reason = 6;
+inline bool ChannelState::has_reason() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ChannelState::set_has_reason() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ChannelState::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ChannelState::clear_reason() {
+  reason_ = 0u;
+  clear_has_reason();
+}
+inline ::google::protobuf::uint32 ChannelState::reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.reason)
+  return reason_;
+}
+inline void ChannelState::set_reason(::google::protobuf::uint32 value) {
+  set_has_reason();
+  reason_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.reason)
+}
+
+// optional .bgs.protocol.channel.v1.ChannelState.PrivacyLevel privacy_level = 7 [default = PRIVACY_LEVEL_OPEN];
+inline bool ChannelState::has_privacy_level() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ChannelState::set_has_privacy_level() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ChannelState::clear_has_privacy_level() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ChannelState::clear_privacy_level() {
+  privacy_level_ = 1;
+  clear_has_privacy_level();
+}
+inline ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel ChannelState::privacy_level() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.privacy_level)
+  return static_cast< ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel >(privacy_level_);
+}
+inline void ChannelState::set_privacy_level(::bgs::protocol::channel::v1::ChannelState_PrivacyLevel value) {
+  assert(::bgs::protocol::channel::v1::ChannelState_PrivacyLevel_IsValid(value));
+  set_has_privacy_level();
+  privacy_level_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.privacy_level)
+}
+
+// optional string name = 8;
+inline bool ChannelState::has_name() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ChannelState::set_has_name() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ChannelState::clear_has_name() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ChannelState::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& ChannelState::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.name)
+  return *name_;
+}
+inline void ChannelState::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.name)
+}
+inline void ChannelState::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.ChannelState.name)
+}
+inline void ChannelState::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.ChannelState.name)
+}
+inline ::std::string* ChannelState::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelState.name)
+  return name_;
+}
+inline ::std::string* ChannelState::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ChannelState::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelState.name)
+}
+
+// optional string delegate_name = 9;
+inline bool ChannelState::has_delegate_name() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void ChannelState::set_has_delegate_name() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void ChannelState::clear_has_delegate_name() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void ChannelState::clear_delegate_name() {
+  if (delegate_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delegate_name_->clear();
+  }
+  clear_has_delegate_name();
+}
+inline const ::std::string& ChannelState::delegate_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.delegate_name)
+  return *delegate_name_;
+}
+inline void ChannelState::set_delegate_name(const ::std::string& value) {
+  set_has_delegate_name();
+  if (delegate_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delegate_name_ = new ::std::string;
+  }
+  delegate_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.delegate_name)
+}
+inline void ChannelState::set_delegate_name(const char* value) {
+  set_has_delegate_name();
+  if (delegate_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delegate_name_ = new ::std::string;
+  }
+  delegate_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.ChannelState.delegate_name)
+}
+inline void ChannelState::set_delegate_name(const char* value, size_t size) {
+  set_has_delegate_name();
+  if (delegate_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delegate_name_ = new ::std::string;
+  }
+  delegate_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.ChannelState.delegate_name)
+}
+inline ::std::string* ChannelState::mutable_delegate_name() {
+  set_has_delegate_name();
+  if (delegate_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delegate_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelState.delegate_name)
+  return delegate_name_;
+}
+inline ::std::string* ChannelState::release_delegate_name() {
+  clear_has_delegate_name();
+  if (delegate_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = delegate_name_;
+    delegate_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ChannelState::set_allocated_delegate_name(::std::string* delegate_name) {
+  if (delegate_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete delegate_name_;
+  }
+  if (delegate_name) {
+    set_has_delegate_name();
+    delegate_name_ = delegate_name;
+  } else {
+    clear_has_delegate_name();
+    delegate_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelState.delegate_name)
+}
+
+// optional string channel_type = 10 [default = "default"];
+inline bool ChannelState::has_channel_type() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void ChannelState::set_has_channel_type() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void ChannelState::clear_has_channel_type() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void ChannelState::clear_channel_type() {
+  if (channel_type_ != _default_channel_type_) {
+    channel_type_->assign(*_default_channel_type_);
+  }
+  clear_has_channel_type();
+}
+inline const ::std::string& ChannelState::channel_type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.channel_type)
+  return *channel_type_;
+}
+inline void ChannelState::set_channel_type(const ::std::string& value) {
+  set_has_channel_type();
+  if (channel_type_ == _default_channel_type_) {
+    channel_type_ = new ::std::string;
+  }
+  channel_type_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.channel_type)
+}
+inline void ChannelState::set_channel_type(const char* value) {
+  set_has_channel_type();
+  if (channel_type_ == _default_channel_type_) {
+    channel_type_ = new ::std::string;
+  }
+  channel_type_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.ChannelState.channel_type)
+}
+inline void ChannelState::set_channel_type(const char* value, size_t size) {
+  set_has_channel_type();
+  if (channel_type_ == _default_channel_type_) {
+    channel_type_ = new ::std::string;
+  }
+  channel_type_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.ChannelState.channel_type)
+}
+inline ::std::string* ChannelState::mutable_channel_type() {
+  set_has_channel_type();
+  if (channel_type_ == _default_channel_type_) {
+    channel_type_ = new ::std::string(*_default_channel_type_);
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelState.channel_type)
+  return channel_type_;
+}
+inline ::std::string* ChannelState::release_channel_type() {
+  clear_has_channel_type();
+  if (channel_type_ == _default_channel_type_) {
+    return NULL;
+  } else {
+    ::std::string* temp = channel_type_;
+    channel_type_ = const_cast< ::std::string*>(_default_channel_type_);
+    return temp;
+  }
+}
+inline void ChannelState::set_allocated_channel_type(::std::string* channel_type) {
+  if (channel_type_ != _default_channel_type_) {
+    delete channel_type_;
+  }
+  if (channel_type) {
+    set_has_channel_type();
+    channel_type_ = channel_type;
+  } else {
+    clear_has_channel_type();
+    channel_type_ = const_cast< ::std::string*>(_default_channel_type_);
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelState.channel_type)
+}
+
+// optional fixed32 program = 11 [default = 0];
+inline bool ChannelState::has_program() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void ChannelState::set_has_program() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void ChannelState::clear_has_program() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void ChannelState::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 ChannelState::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.program)
+  return program_;
+}
+inline void ChannelState::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.program)
+}
+
+// optional bool allow_offline_members = 12 [default = false];
+inline bool ChannelState::has_allow_offline_members() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void ChannelState::set_has_allow_offline_members() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void ChannelState::clear_has_allow_offline_members() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void ChannelState::clear_allow_offline_members() {
+  allow_offline_members_ = false;
+  clear_has_allow_offline_members();
+}
+inline bool ChannelState::allow_offline_members() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.allow_offline_members)
+  return allow_offline_members_;
+}
+inline void ChannelState::set_allow_offline_members(bool value) {
+  set_has_allow_offline_members();
+  allow_offline_members_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.allow_offline_members)
+}
+
+// optional bool subscribe_to_presence = 13 [default = true];
+inline bool ChannelState::has_subscribe_to_presence() const {
+  return (_has_bits_[0] & 0x00001000u) != 0;
+}
+inline void ChannelState::set_has_subscribe_to_presence() {
+  _has_bits_[0] |= 0x00001000u;
+}
+inline void ChannelState::clear_has_subscribe_to_presence() {
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline void ChannelState::clear_subscribe_to_presence() {
+  subscribe_to_presence_ = true;
+  clear_has_subscribe_to_presence();
+}
+inline bool ChannelState::subscribe_to_presence() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.subscribe_to_presence)
+  return subscribe_to_presence_;
+}
+inline void ChannelState::set_subscribe_to_presence(bool value) {
+  set_has_subscribe_to_presence();
+  subscribe_to_presence_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.subscribe_to_presence)
+}
+
+// optional bool destroy_on_founder_leave = 14 [default = false];
+inline bool ChannelState::has_destroy_on_founder_leave() const {
+  return (_has_bits_[0] & 0x00002000u) != 0;
+}
+inline void ChannelState::set_has_destroy_on_founder_leave() {
+  _has_bits_[0] |= 0x00002000u;
+}
+inline void ChannelState::clear_has_destroy_on_founder_leave() {
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline void ChannelState::clear_destroy_on_founder_leave() {
+  destroy_on_founder_leave_ = false;
+  clear_has_destroy_on_founder_leave();
+}
+inline bool ChannelState::destroy_on_founder_leave() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.destroy_on_founder_leave)
+  return destroy_on_founder_leave_;
+}
+inline void ChannelState::set_destroy_on_founder_leave(bool value) {
+  set_has_destroy_on_founder_leave();
+  destroy_on_founder_leave_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.destroy_on_founder_leave)
+}
+
+// -------------------------------------------------------------------
+
+// MemberState
+
+// repeated .bgs.protocol.Attribute attribute = 1;
+inline int MemberState::attribute_size() const {
+  return attribute_.size();
+}
+inline void MemberState::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::Attribute& MemberState::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberState.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::Attribute* MemberState::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberState.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* MemberState::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.MemberState.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+MemberState::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.MemberState.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+MemberState::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.MemberState.attribute)
+  return &attribute_;
+}
+
+// repeated uint32 role = 2 [packed = true];
+inline int MemberState::role_size() const {
+  return role_.size();
+}
+inline void MemberState::clear_role() {
+  role_.Clear();
+}
+inline ::google::protobuf::uint32 MemberState::role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberState.role)
+  return role_.Get(index);
+}
+inline void MemberState::set_role(int index, ::google::protobuf::uint32 value) {
+  role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.MemberState.role)
+}
+inline void MemberState::add_role(::google::protobuf::uint32 value) {
+  role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.MemberState.role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+MemberState::role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.MemberState.role)
+  return role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+MemberState::mutable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.MemberState.role)
+  return &role_;
+}
+
+// optional uint64 privileges = 3 [default = 0];
+inline bool MemberState::has_privileges() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void MemberState::set_has_privileges() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void MemberState::clear_has_privileges() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void MemberState::clear_privileges() {
+  privileges_ = GOOGLE_ULONGLONG(0);
+  clear_has_privileges();
+}
+inline ::google::protobuf::uint64 MemberState::privileges() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberState.privileges)
+  return privileges_;
+}
+inline void MemberState::set_privileges(::google::protobuf::uint64 value) {
+  set_has_privileges();
+  privileges_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.MemberState.privileges)
+}
+
+// optional .bgs.protocol.AccountInfo info = 4;
+inline bool MemberState::has_info() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void MemberState::set_has_info() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void MemberState::clear_has_info() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void MemberState::clear_info() {
+  if (info_ != NULL) info_->::bgs::protocol::AccountInfo::Clear();
+  clear_has_info();
+}
+inline const ::bgs::protocol::AccountInfo& MemberState::info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberState.info)
+  return info_ != NULL ? *info_ : *default_instance_->info_;
+}
+inline ::bgs::protocol::AccountInfo* MemberState::mutable_info() {
+  set_has_info();
+  if (info_ == NULL) info_ = new ::bgs::protocol::AccountInfo;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberState.info)
+  return info_;
+}
+inline ::bgs::protocol::AccountInfo* MemberState::release_info() {
+  clear_has_info();
+  ::bgs::protocol::AccountInfo* temp = info_;
+  info_ = NULL;
+  return temp;
+}
+inline void MemberState::set_allocated_info(::bgs::protocol::AccountInfo* info) {
+  delete info_;
+  info_ = info;
+  if (info) {
+    set_has_info();
+  } else {
+    clear_has_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberState.info)
+}
+
+// optional bool DEPRECATED_hidden = 5 [default = false, deprecated = true];
+inline bool MemberState::has_deprecated_hidden() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void MemberState::set_has_deprecated_hidden() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void MemberState::clear_has_deprecated_hidden() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void MemberState::clear_deprecated_hidden() {
+  deprecated_hidden_ = false;
+  clear_has_deprecated_hidden();
+}
+inline bool MemberState::deprecated_hidden() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberState.DEPRECATED_hidden)
+  return deprecated_hidden_;
+}
+inline void MemberState::set_deprecated_hidden(bool value) {
+  set_has_deprecated_hidden();
+  deprecated_hidden_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.MemberState.DEPRECATED_hidden)
+}
+
+// -------------------------------------------------------------------
+
+// Member
+
+// required .bgs.protocol.Identity identity = 1;
+inline bool Member::has_identity() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Member::set_has_identity() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Member::clear_has_identity() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Member::clear_identity() {
+  if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear();
+  clear_has_identity();
+}
+inline const ::bgs::protocol::Identity& Member::identity() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.Member.identity)
+  return identity_ != NULL ? *identity_ : *default_instance_->identity_;
+}
+inline ::bgs::protocol::Identity* Member::mutable_identity() {
+  set_has_identity();
+  if (identity_ == NULL) identity_ = new ::bgs::protocol::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.Member.identity)
+  return identity_;
+}
+inline ::bgs::protocol::Identity* Member::release_identity() {
+  clear_has_identity();
+  ::bgs::protocol::Identity* temp = identity_;
+  identity_ = NULL;
+  return temp;
+}
+inline void Member::set_allocated_identity(::bgs::protocol::Identity* identity) {
+  delete identity_;
+  identity_ = identity;
+  if (identity) {
+    set_has_identity();
+  } else {
+    clear_has_identity();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.Member.identity)
+}
+
+// required .bgs.protocol.channel.v1.MemberState state = 2;
+inline bool Member::has_state() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Member::set_has_state() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Member::clear_has_state() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Member::clear_state() {
+  if (state_ != NULL) state_->::bgs::protocol::channel::v1::MemberState::Clear();
+  clear_has_state();
+}
+inline const ::bgs::protocol::channel::v1::MemberState& Member::state() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.Member.state)
+  return state_ != NULL ? *state_ : *default_instance_->state_;
+}
+inline ::bgs::protocol::channel::v1::MemberState* Member::mutable_state() {
+  set_has_state();
+  if (state_ == NULL) state_ = new ::bgs::protocol::channel::v1::MemberState;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.Member.state)
+  return state_;
+}
+inline ::bgs::protocol::channel::v1::MemberState* Member::release_state() {
+  clear_has_state();
+  ::bgs::protocol::channel::v1::MemberState* temp = state_;
+  state_ = NULL;
+  return temp;
+}
+inline void Member::set_allocated_state(::bgs::protocol::channel::v1::MemberState* state) {
+  delete state_;
+  state_ = state;
+  if (state) {
+    set_has_state();
+  } else {
+    clear_has_state();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.Member.state)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace channel
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel>() {
+  return ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel_descriptor();
+}
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_channel_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/connection_service.pb.cc b/src/server/proto/Client/connection_service.pb.cc
new file mode 100644
index 00000000000..97a3d5275bc
--- /dev/null
+++ b/src/server/proto/Client/connection_service.pb.cc
@@ -0,0 +1,3876 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: connection_service.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "connection_service.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+#include "BattlenetRpcErrorCodes.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace connection {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* ConnectRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ConnectRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ConnectionMeteringContentHandles_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ConnectionMeteringContentHandles_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ConnectResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ConnectResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* BoundService_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  BoundService_reflection_ = NULL;
+const ::google::protobuf::Descriptor* BindRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  BindRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* BindResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  BindResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* EchoRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  EchoRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* EchoResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  EchoResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* DisconnectRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  DisconnectRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* DisconnectNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  DisconnectNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* EncryptRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  EncryptRequest_reflection_ = NULL;
+const ::google::protobuf::ServiceDescriptor* ConnectionService_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_connection_5fservice_2eproto() {
+  protobuf_AddDesc_connection_5fservice_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "connection_service.proto");
+  GOOGLE_CHECK(file != NULL);
+  ConnectRequest_descriptor_ = file->message_type(0);
+  static const int ConnectRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectRequest, client_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectRequest, bind_request_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectRequest, use_bindless_rpc_),
+  };
+  ConnectRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ConnectRequest_descriptor_,
+      ConnectRequest::default_instance_,
+      ConnectRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ConnectRequest));
+  ConnectionMeteringContentHandles_descriptor_ = file->message_type(1);
+  static const int ConnectionMeteringContentHandles_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectionMeteringContentHandles, content_handle_),
+  };
+  ConnectionMeteringContentHandles_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ConnectionMeteringContentHandles_descriptor_,
+      ConnectionMeteringContentHandles::default_instance_,
+      ConnectionMeteringContentHandles_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectionMeteringContentHandles, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectionMeteringContentHandles, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ConnectionMeteringContentHandles));
+  ConnectResponse_descriptor_ = file->message_type(2);
+  static const int ConnectResponse_offsets_[8] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, server_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, client_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, bind_result_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, bind_response_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, content_handle_array_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, server_time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, use_bindless_rpc_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, binary_content_handle_array_),
+  };
+  ConnectResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ConnectResponse_descriptor_,
+      ConnectResponse::default_instance_,
+      ConnectResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ConnectResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ConnectResponse));
+  BoundService_descriptor_ = file->message_type(3);
+  static const int BoundService_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BoundService, hash_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BoundService, id_),
+  };
+  BoundService_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      BoundService_descriptor_,
+      BoundService::default_instance_,
+      BoundService_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BoundService, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BoundService, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(BoundService));
+  BindRequest_descriptor_ = file->message_type(4);
+  static const int BindRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindRequest, deprecated_imported_service_hash_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindRequest, deprecated_exported_service_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindRequest, exported_service_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindRequest, imported_service_),
+  };
+  BindRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      BindRequest_descriptor_,
+      BindRequest::default_instance_,
+      BindRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(BindRequest));
+  BindResponse_descriptor_ = file->message_type(5);
+  static const int BindResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindResponse, imported_service_id_),
+  };
+  BindResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      BindResponse_descriptor_,
+      BindResponse::default_instance_,
+      BindResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BindResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(BindResponse));
+  EchoRequest_descriptor_ = file->message_type(6);
+  static const int EchoRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoRequest, time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoRequest, network_only_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoRequest, payload_),
+  };
+  EchoRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      EchoRequest_descriptor_,
+      EchoRequest::default_instance_,
+      EchoRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(EchoRequest));
+  EchoResponse_descriptor_ = file->message_type(7);
+  static const int EchoResponse_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoResponse, time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoResponse, payload_),
+  };
+  EchoResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      EchoResponse_descriptor_,
+      EchoResponse::default_instance_,
+      EchoResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EchoResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(EchoResponse));
+  DisconnectRequest_descriptor_ = file->message_type(8);
+  static const int DisconnectRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DisconnectRequest, error_code_),
+  };
+  DisconnectRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      DisconnectRequest_descriptor_,
+      DisconnectRequest::default_instance_,
+      DisconnectRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DisconnectRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DisconnectRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(DisconnectRequest));
+  DisconnectNotification_descriptor_ = file->message_type(9);
+  static const int DisconnectNotification_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DisconnectNotification, error_code_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DisconnectNotification, reason_),
+  };
+  DisconnectNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      DisconnectNotification_descriptor_,
+      DisconnectNotification::default_instance_,
+      DisconnectNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DisconnectNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DisconnectNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(DisconnectNotification));
+  EncryptRequest_descriptor_ = file->message_type(10);
+  static const int EncryptRequest_offsets_[1] = {
+  };
+  EncryptRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      EncryptRequest_descriptor_,
+      EncryptRequest::default_instance_,
+      EncryptRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EncryptRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EncryptRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(EncryptRequest));
+  ConnectionService_descriptor_ = file->service(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_connection_5fservice_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ConnectRequest_descriptor_, &ConnectRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ConnectionMeteringContentHandles_descriptor_, &ConnectionMeteringContentHandles::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ConnectResponse_descriptor_, &ConnectResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    BoundService_descriptor_, &BoundService::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    BindRequest_descriptor_, &BindRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    BindResponse_descriptor_, &BindResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    EchoRequest_descriptor_, &EchoRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    EchoResponse_descriptor_, &EchoResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    DisconnectRequest_descriptor_, &DisconnectRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    DisconnectNotification_descriptor_, &DisconnectNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    EncryptRequest_descriptor_, &EncryptRequest::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_connection_5fservice_2eproto() {
+  delete ConnectRequest::default_instance_;
+  delete ConnectRequest_reflection_;
+  delete ConnectionMeteringContentHandles::default_instance_;
+  delete ConnectionMeteringContentHandles_reflection_;
+  delete ConnectResponse::default_instance_;
+  delete ConnectResponse_reflection_;
+  delete BoundService::default_instance_;
+  delete BoundService_reflection_;
+  delete BindRequest::default_instance_;
+  delete BindRequest_reflection_;
+  delete BindResponse::default_instance_;
+  delete BindResponse_reflection_;
+  delete EchoRequest::default_instance_;
+  delete EchoRequest_reflection_;
+  delete EchoResponse::default_instance_;
+  delete EchoResponse_reflection_;
+  delete DisconnectRequest::default_instance_;
+  delete DisconnectRequest_reflection_;
+  delete DisconnectNotification::default_instance_;
+  delete DisconnectNotification_reflection_;
+  delete EncryptRequest::default_instance_;
+  delete EncryptRequest_reflection_;
+}
+
+void protobuf_AddDesc_connection_5fservice_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_content_5fhandle_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\030connection_service.proto\022\032bgs.protocol"
+    ".connection.v1\032\032content_handle_types.pro"
+    "to\032\017rpc_types.proto\"\233\001\n\016ConnectRequest\022*"
+    "\n\tclient_id\030\001 \001(\0132\027.bgs.protocol.Process"
+    "Id\022=\n\014bind_request\030\002 \001(\0132\'.bgs.protocol."
+    "connection.v1.BindRequest\022\036\n\020use_bindles"
+    "s_rpc\030\003 \001(\010:\004true\"W\n ConnectionMeteringC"
+    "ontentHandles\0223\n\016content_handle\030\001 \003(\0132\033."
+    "bgs.protocol.ContentHandle\"\264\003\n\017ConnectRe"
+    "sponse\022*\n\tserver_id\030\001 \002(\0132\027.bgs.protocol"
+    ".ProcessId\022*\n\tclient_id\030\002 \001(\0132\027.bgs.prot"
+    "ocol.ProcessId\022\023\n\013bind_result\030\003 \001(\r\022\?\n\rb"
+    "ind_response\030\004 \001(\0132(.bgs.protocol.connec"
+    "tion.v1.BindResponse\022Z\n\024content_handle_a"
+    "rray\030\005 \001(\0132<.bgs.protocol.connection.v1."
+    "ConnectionMeteringContentHandles\022\023\n\013serv"
+    "er_time\030\006 \001(\004\022\037\n\020use_bindless_rpc\030\007 \001(\010:"
+    "\005false\022a\n\033binary_content_handle_array\030\010 "
+    "\001(\0132<.bgs.protocol.connection.v1.Connect"
+    "ionMeteringContentHandles\"(\n\014BoundServic"
+    "e\022\014\n\004hash\030\001 \002(\007\022\n\n\002id\030\002 \002(\r\"\230\002\n\013BindRequ"
+    "est\022.\n deprecated_imported_service_hash\030"
+    "\001 \003(\007B\004\020\001\030\001\022Q\n\033deprecated_exported_servi"
+    "ce\030\002 \003(\0132(.bgs.protocol.connection.v1.Bo"
+    "undServiceB\002\030\001\022B\n\020exported_service\030\003 \003(\013"
+    "2(.bgs.protocol.connection.v1.BoundServi"
+    "ce\022B\n\020imported_service\030\004 \003(\0132(.bgs.proto"
+    "col.connection.v1.BoundService\"1\n\014BindRe"
+    "sponse\022!\n\023imported_service_id\030\001 \003(\rB\004\020\001\030"
+    "\001\"I\n\013EchoRequest\022\014\n\004time\030\001 \001(\006\022\033\n\014networ"
+    "k_only\030\002 \001(\010:\005false\022\017\n\007payload\030\003 \001(\014\"-\n\014"
+    "EchoResponse\022\014\n\004time\030\001 \001(\006\022\017\n\007payload\030\002 "
+    "\001(\014\"\'\n\021DisconnectRequest\022\022\n\nerror_code\030\001"
+    " \002(\r\"<\n\026DisconnectNotification\022\022\n\nerror_"
+    "code\030\001 \002(\r\022\016\n\006reason\030\002 \001(\t\"\020\n\016EncryptReq"
+    "uest2\330\005\n\021ConnectionService\022h\n\007Connect\022*."
+    "bgs.protocol.connection.v1.ConnectReques"
+    "t\032+.bgs.protocol.connection.v1.ConnectRe"
+    "sponse\"\004\200\265\030\001\022b\n\004Bind\022\'.bgs.protocol.conn"
+    "ection.v1.BindRequest\032(.bgs.protocol.con"
+    "nection.v1.BindResponse\"\007\210\002\001\200\265\030\002\022_\n\004Echo"
+    "\022\'.bgs.protocol.connection.v1.EchoReques"
+    "t\032(.bgs.protocol.connection.v1.EchoRespo"
+    "nse\"\004\200\265\030\003\022f\n\017ForceDisconnect\0222.bgs.proto"
+    "col.connection.v1.DisconnectNotification"
+    "\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\004\022B\n\tKee"
+    "pAlive\022\024.bgs.protocol.NoData\032\031.bgs.proto"
+    "col.NO_RESPONSE\"\004\200\265\030\005\022T\n\007Encrypt\022*.bgs.p"
+    "rotocol.connection.v1.EncryptRequest\032\024.b"
+    "gs.protocol.NoData\"\007\210\002\001\200\265\030\006\022c\n\021RequestDi"
+    "sconnect\022-.bgs.protocol.connection.v1.Di"
+    "sconnectRequest\032\031.bgs.protocol.NO_RESPON"
+    "SE\"\004\200\265\030\007\032-\312>*bnet.protocol.connection.Co"
+    "nnectionServiceB=\n\033bnet.protocol.connect"
+    "ion.v1B\026ConnectionServiceProtoH\001\200\001\000\210\001\001", 2198);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "connection_service.proto", &protobuf_RegisterTypes);
+  ConnectRequest::default_instance_ = new ConnectRequest();
+  ConnectionMeteringContentHandles::default_instance_ = new ConnectionMeteringContentHandles();
+  ConnectResponse::default_instance_ = new ConnectResponse();
+  BoundService::default_instance_ = new BoundService();
+  BindRequest::default_instance_ = new BindRequest();
+  BindResponse::default_instance_ = new BindResponse();
+  EchoRequest::default_instance_ = new EchoRequest();
+  EchoResponse::default_instance_ = new EchoResponse();
+  DisconnectRequest::default_instance_ = new DisconnectRequest();
+  DisconnectNotification::default_instance_ = new DisconnectNotification();
+  EncryptRequest::default_instance_ = new EncryptRequest();
+  ConnectRequest::default_instance_->InitAsDefaultInstance();
+  ConnectionMeteringContentHandles::default_instance_->InitAsDefaultInstance();
+  ConnectResponse::default_instance_->InitAsDefaultInstance();
+  BoundService::default_instance_->InitAsDefaultInstance();
+  BindRequest::default_instance_->InitAsDefaultInstance();
+  BindResponse::default_instance_->InitAsDefaultInstance();
+  EchoRequest::default_instance_->InitAsDefaultInstance();
+  EchoResponse::default_instance_->InitAsDefaultInstance();
+  DisconnectRequest::default_instance_->InitAsDefaultInstance();
+  DisconnectNotification::default_instance_->InitAsDefaultInstance();
+  EncryptRequest::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_connection_5fservice_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_connection_5fservice_2eproto {
+  StaticDescriptorInitializer_connection_5fservice_2eproto() {
+    protobuf_AddDesc_connection_5fservice_2eproto();
+  }
+} static_descriptor_initializer_connection_5fservice_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ConnectRequest::kClientIdFieldNumber;
+const int ConnectRequest::kBindRequestFieldNumber;
+const int ConnectRequest::kUseBindlessRpcFieldNumber;
+#endif  // !_MSC_VER
+
+ConnectRequest::ConnectRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.ConnectRequest)
+}
+
+void ConnectRequest::InitAsDefaultInstance() {
+  client_id_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+  bind_request_ = const_cast< ::bgs::protocol::connection::v1::BindRequest*>(&::bgs::protocol::connection::v1::BindRequest::default_instance());
+}
+
+ConnectRequest::ConnectRequest(const ConnectRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.ConnectRequest)
+}
+
+void ConnectRequest::SharedCtor() {
+  _cached_size_ = 0;
+  client_id_ = NULL;
+  bind_request_ = NULL;
+  use_bindless_rpc_ = true;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ConnectRequest::~ConnectRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.ConnectRequest)
+  SharedDtor();
+}
+
+void ConnectRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete client_id_;
+    delete bind_request_;
+  }
+}
+
+void ConnectRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ConnectRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ConnectRequest_descriptor_;
+}
+
+const ConnectRequest& ConnectRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ConnectRequest* ConnectRequest::default_instance_ = NULL;
+
+ConnectRequest* ConnectRequest::New() const {
+  return new ConnectRequest;
+}
+
+void ConnectRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_client_id()) {
+      if (client_id_ != NULL) client_id_->::bgs::protocol::ProcessId::Clear();
+    }
+    if (has_bind_request()) {
+      if (bind_request_ != NULL) bind_request_->::bgs::protocol::connection::v1::BindRequest::Clear();
+    }
+    use_bindless_rpc_ = true;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ConnectRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.ConnectRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.ProcessId client_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_client_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_bind_request;
+        break;
+      }
+
+      // optional .bgs.protocol.connection.v1.BindRequest bind_request = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_bind_request:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_bind_request()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_use_bindless_rpc;
+        break;
+      }
+
+      // optional bool use_bindless_rpc = 3 [default = true];
+      case 3: {
+        if (tag == 24) {
+         parse_use_bindless_rpc:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &use_bindless_rpc_)));
+          set_has_use_bindless_rpc();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.connection.v1.ConnectRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.ConnectRequest)
+  return false;
+#undef DO_
+}
+
+void ConnectRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.ConnectRequest)
+  // optional .bgs.protocol.ProcessId client_id = 1;
+  if (has_client_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->client_id(), output);
+  }
+
+  // optional .bgs.protocol.connection.v1.BindRequest bind_request = 2;
+  if (has_bind_request()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->bind_request(), output);
+  }
+
+  // optional bool use_bindless_rpc = 3 [default = true];
+  if (has_use_bindless_rpc()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->use_bindless_rpc(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.ConnectRequest)
+}
+
+::google::protobuf::uint8* ConnectRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.ConnectRequest)
+  // optional .bgs.protocol.ProcessId client_id = 1;
+  if (has_client_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->client_id(), target);
+  }
+
+  // optional .bgs.protocol.connection.v1.BindRequest bind_request = 2;
+  if (has_bind_request()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->bind_request(), target);
+  }
+
+  // optional bool use_bindless_rpc = 3 [default = true];
+  if (has_use_bindless_rpc()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->use_bindless_rpc(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.ConnectRequest)
+  return target;
+}
+
+int ConnectRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.ProcessId client_id = 1;
+    if (has_client_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->client_id());
+    }
+
+    // optional .bgs.protocol.connection.v1.BindRequest bind_request = 2;
+    if (has_bind_request()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->bind_request());
+    }
+
+    // optional bool use_bindless_rpc = 3 [default = true];
+    if (has_use_bindless_rpc()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ConnectRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ConnectRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ConnectRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ConnectRequest::MergeFrom(const ConnectRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_client_id()) {
+      mutable_client_id()->::bgs::protocol::ProcessId::MergeFrom(from.client_id());
+    }
+    if (from.has_bind_request()) {
+      mutable_bind_request()->::bgs::protocol::connection::v1::BindRequest::MergeFrom(from.bind_request());
+    }
+    if (from.has_use_bindless_rpc()) {
+      set_use_bindless_rpc(from.use_bindless_rpc());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ConnectRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ConnectRequest::CopyFrom(const ConnectRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ConnectRequest::IsInitialized() const {
+
+  if (has_client_id()) {
+    if (!this->client_id().IsInitialized()) return false;
+  }
+  if (has_bind_request()) {
+    if (!this->bind_request().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ConnectRequest::Swap(ConnectRequest* other) {
+  if (other != this) {
+    std::swap(client_id_, other->client_id_);
+    std::swap(bind_request_, other->bind_request_);
+    std::swap(use_bindless_rpc_, other->use_bindless_rpc_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ConnectRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ConnectRequest_descriptor_;
+  metadata.reflection = ConnectRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ConnectionMeteringContentHandles::kContentHandleFieldNumber;
+#endif  // !_MSC_VER
+
+ConnectionMeteringContentHandles::ConnectionMeteringContentHandles()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.ConnectionMeteringContentHandles)
+}
+
+void ConnectionMeteringContentHandles::InitAsDefaultInstance() {
+}
+
+ConnectionMeteringContentHandles::ConnectionMeteringContentHandles(const ConnectionMeteringContentHandles& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.ConnectionMeteringContentHandles)
+}
+
+void ConnectionMeteringContentHandles::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ConnectionMeteringContentHandles::~ConnectionMeteringContentHandles() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.ConnectionMeteringContentHandles)
+  SharedDtor();
+}
+
+void ConnectionMeteringContentHandles::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ConnectionMeteringContentHandles::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ConnectionMeteringContentHandles::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ConnectionMeteringContentHandles_descriptor_;
+}
+
+const ConnectionMeteringContentHandles& ConnectionMeteringContentHandles::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ConnectionMeteringContentHandles* ConnectionMeteringContentHandles::default_instance_ = NULL;
+
+ConnectionMeteringContentHandles* ConnectionMeteringContentHandles::New() const {
+  return new ConnectionMeteringContentHandles;
+}
+
+void ConnectionMeteringContentHandles::Clear() {
+  content_handle_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ConnectionMeteringContentHandles::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.ConnectionMeteringContentHandles)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.ContentHandle content_handle = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_content_handle:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_content_handle()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_content_handle;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.connection.v1.ConnectionMeteringContentHandles)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.ConnectionMeteringContentHandles)
+  return false;
+#undef DO_
+}
+
+void ConnectionMeteringContentHandles::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.ConnectionMeteringContentHandles)
+  // repeated .bgs.protocol.ContentHandle content_handle = 1;
+  for (int i = 0; i < this->content_handle_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->content_handle(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.ConnectionMeteringContentHandles)
+}
+
+::google::protobuf::uint8* ConnectionMeteringContentHandles::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.ConnectionMeteringContentHandles)
+  // repeated .bgs.protocol.ContentHandle content_handle = 1;
+  for (int i = 0; i < this->content_handle_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->content_handle(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.ConnectionMeteringContentHandles)
+  return target;
+}
+
+int ConnectionMeteringContentHandles::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.ContentHandle content_handle = 1;
+  total_size += 1 * this->content_handle_size();
+  for (int i = 0; i < this->content_handle_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->content_handle(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ConnectionMeteringContentHandles::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ConnectionMeteringContentHandles* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ConnectionMeteringContentHandles*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ConnectionMeteringContentHandles::MergeFrom(const ConnectionMeteringContentHandles& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  content_handle_.MergeFrom(from.content_handle_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ConnectionMeteringContentHandles::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ConnectionMeteringContentHandles::CopyFrom(const ConnectionMeteringContentHandles& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ConnectionMeteringContentHandles::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->content_handle())) return false;
+  return true;
+}
+
+void ConnectionMeteringContentHandles::Swap(ConnectionMeteringContentHandles* other) {
+  if (other != this) {
+    content_handle_.Swap(&other->content_handle_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ConnectionMeteringContentHandles::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ConnectionMeteringContentHandles_descriptor_;
+  metadata.reflection = ConnectionMeteringContentHandles_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ConnectResponse::kServerIdFieldNumber;
+const int ConnectResponse::kClientIdFieldNumber;
+const int ConnectResponse::kBindResultFieldNumber;
+const int ConnectResponse::kBindResponseFieldNumber;
+const int ConnectResponse::kContentHandleArrayFieldNumber;
+const int ConnectResponse::kServerTimeFieldNumber;
+const int ConnectResponse::kUseBindlessRpcFieldNumber;
+const int ConnectResponse::kBinaryContentHandleArrayFieldNumber;
+#endif  // !_MSC_VER
+
+ConnectResponse::ConnectResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.ConnectResponse)
+}
+
+void ConnectResponse::InitAsDefaultInstance() {
+  server_id_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+  client_id_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+  bind_response_ = const_cast< ::bgs::protocol::connection::v1::BindResponse*>(&::bgs::protocol::connection::v1::BindResponse::default_instance());
+  content_handle_array_ = const_cast< ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles*>(&::bgs::protocol::connection::v1::ConnectionMeteringContentHandles::default_instance());
+  binary_content_handle_array_ = const_cast< ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles*>(&::bgs::protocol::connection::v1::ConnectionMeteringContentHandles::default_instance());
+}
+
+ConnectResponse::ConnectResponse(const ConnectResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.ConnectResponse)
+}
+
+void ConnectResponse::SharedCtor() {
+  _cached_size_ = 0;
+  server_id_ = NULL;
+  client_id_ = NULL;
+  bind_result_ = 0u;
+  bind_response_ = NULL;
+  content_handle_array_ = NULL;
+  server_time_ = GOOGLE_ULONGLONG(0);
+  use_bindless_rpc_ = false;
+  binary_content_handle_array_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ConnectResponse::~ConnectResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.ConnectResponse)
+  SharedDtor();
+}
+
+void ConnectResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete server_id_;
+    delete client_id_;
+    delete bind_response_;
+    delete content_handle_array_;
+    delete binary_content_handle_array_;
+  }
+}
+
+void ConnectResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ConnectResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ConnectResponse_descriptor_;
+}
+
+const ConnectResponse& ConnectResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ConnectResponse* ConnectResponse::default_instance_ = NULL;
+
+ConnectResponse* ConnectResponse::New() const {
+  return new ConnectResponse;
+}
+
+void ConnectResponse::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ConnectResponse*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 255) {
+    ZR_(bind_result_, server_time_);
+    if (has_server_id()) {
+      if (server_id_ != NULL) server_id_->::bgs::protocol::ProcessId::Clear();
+    }
+    if (has_client_id()) {
+      if (client_id_ != NULL) client_id_->::bgs::protocol::ProcessId::Clear();
+    }
+    if (has_bind_response()) {
+      if (bind_response_ != NULL) bind_response_->::bgs::protocol::connection::v1::BindResponse::Clear();
+    }
+    if (has_content_handle_array()) {
+      if (content_handle_array_ != NULL) content_handle_array_->::bgs::protocol::connection::v1::ConnectionMeteringContentHandles::Clear();
+    }
+    if (has_binary_content_handle_array()) {
+      if (binary_content_handle_array_ != NULL) binary_content_handle_array_->::bgs::protocol::connection::v1::ConnectionMeteringContentHandles::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ConnectResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.ConnectResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.ProcessId server_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_server_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_client_id;
+        break;
+      }
+
+      // optional .bgs.protocol.ProcessId client_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_client_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_client_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_bind_result;
+        break;
+      }
+
+      // optional uint32 bind_result = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_bind_result:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &bind_result_)));
+          set_has_bind_result();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_bind_response;
+        break;
+      }
+
+      // optional .bgs.protocol.connection.v1.BindResponse bind_response = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_bind_response:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_bind_response()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_content_handle_array;
+        break;
+      }
+
+      // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles content_handle_array = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_content_handle_array:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_content_handle_array()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_server_time;
+        break;
+      }
+
+      // optional uint64 server_time = 6;
+      case 6: {
+        if (tag == 48) {
+         parse_server_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &server_time_)));
+          set_has_server_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_use_bindless_rpc;
+        break;
+      }
+
+      // optional bool use_bindless_rpc = 7 [default = false];
+      case 7: {
+        if (tag == 56) {
+         parse_use_bindless_rpc:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &use_bindless_rpc_)));
+          set_has_use_bindless_rpc();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_binary_content_handle_array;
+        break;
+      }
+
+      // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles binary_content_handle_array = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_binary_content_handle_array:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_binary_content_handle_array()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.connection.v1.ConnectResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.ConnectResponse)
+  return false;
+#undef DO_
+}
+
+void ConnectResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.ConnectResponse)
+  // required .bgs.protocol.ProcessId server_id = 1;
+  if (has_server_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->server_id(), output);
+  }
+
+  // optional .bgs.protocol.ProcessId client_id = 2;
+  if (has_client_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->client_id(), output);
+  }
+
+  // optional uint32 bind_result = 3;
+  if (has_bind_result()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->bind_result(), output);
+  }
+
+  // optional .bgs.protocol.connection.v1.BindResponse bind_response = 4;
+  if (has_bind_response()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->bind_response(), output);
+  }
+
+  // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles content_handle_array = 5;
+  if (has_content_handle_array()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->content_handle_array(), output);
+  }
+
+  // optional uint64 server_time = 6;
+  if (has_server_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(6, this->server_time(), output);
+  }
+
+  // optional bool use_bindless_rpc = 7 [default = false];
+  if (has_use_bindless_rpc()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->use_bindless_rpc(), output);
+  }
+
+  // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles binary_content_handle_array = 8;
+  if (has_binary_content_handle_array()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      8, this->binary_content_handle_array(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.ConnectResponse)
+}
+
+::google::protobuf::uint8* ConnectResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.ConnectResponse)
+  // required .bgs.protocol.ProcessId server_id = 1;
+  if (has_server_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->server_id(), target);
+  }
+
+  // optional .bgs.protocol.ProcessId client_id = 2;
+  if (has_client_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->client_id(), target);
+  }
+
+  // optional uint32 bind_result = 3;
+  if (has_bind_result()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->bind_result(), target);
+  }
+
+  // optional .bgs.protocol.connection.v1.BindResponse bind_response = 4;
+  if (has_bind_response()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->bind_response(), target);
+  }
+
+  // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles content_handle_array = 5;
+  if (has_content_handle_array()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->content_handle_array(), target);
+  }
+
+  // optional uint64 server_time = 6;
+  if (has_server_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(6, this->server_time(), target);
+  }
+
+  // optional bool use_bindless_rpc = 7 [default = false];
+  if (has_use_bindless_rpc()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->use_bindless_rpc(), target);
+  }
+
+  // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles binary_content_handle_array = 8;
+  if (has_binary_content_handle_array()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        8, this->binary_content_handle_array(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.ConnectResponse)
+  return target;
+}
+
+int ConnectResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.ProcessId server_id = 1;
+    if (has_server_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->server_id());
+    }
+
+    // optional .bgs.protocol.ProcessId client_id = 2;
+    if (has_client_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->client_id());
+    }
+
+    // optional uint32 bind_result = 3;
+    if (has_bind_result()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->bind_result());
+    }
+
+    // optional .bgs.protocol.connection.v1.BindResponse bind_response = 4;
+    if (has_bind_response()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->bind_response());
+    }
+
+    // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles content_handle_array = 5;
+    if (has_content_handle_array()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->content_handle_array());
+    }
+
+    // optional uint64 server_time = 6;
+    if (has_server_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->server_time());
+    }
+
+    // optional bool use_bindless_rpc = 7 [default = false];
+    if (has_use_bindless_rpc()) {
+      total_size += 1 + 1;
+    }
+
+    // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles binary_content_handle_array = 8;
+    if (has_binary_content_handle_array()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->binary_content_handle_array());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ConnectResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ConnectResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ConnectResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ConnectResponse::MergeFrom(const ConnectResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_server_id()) {
+      mutable_server_id()->::bgs::protocol::ProcessId::MergeFrom(from.server_id());
+    }
+    if (from.has_client_id()) {
+      mutable_client_id()->::bgs::protocol::ProcessId::MergeFrom(from.client_id());
+    }
+    if (from.has_bind_result()) {
+      set_bind_result(from.bind_result());
+    }
+    if (from.has_bind_response()) {
+      mutable_bind_response()->::bgs::protocol::connection::v1::BindResponse::MergeFrom(from.bind_response());
+    }
+    if (from.has_content_handle_array()) {
+      mutable_content_handle_array()->::bgs::protocol::connection::v1::ConnectionMeteringContentHandles::MergeFrom(from.content_handle_array());
+    }
+    if (from.has_server_time()) {
+      set_server_time(from.server_time());
+    }
+    if (from.has_use_bindless_rpc()) {
+      set_use_bindless_rpc(from.use_bindless_rpc());
+    }
+    if (from.has_binary_content_handle_array()) {
+      mutable_binary_content_handle_array()->::bgs::protocol::connection::v1::ConnectionMeteringContentHandles::MergeFrom(from.binary_content_handle_array());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ConnectResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ConnectResponse::CopyFrom(const ConnectResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ConnectResponse::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_server_id()) {
+    if (!this->server_id().IsInitialized()) return false;
+  }
+  if (has_client_id()) {
+    if (!this->client_id().IsInitialized()) return false;
+  }
+  if (has_content_handle_array()) {
+    if (!this->content_handle_array().IsInitialized()) return false;
+  }
+  if (has_binary_content_handle_array()) {
+    if (!this->binary_content_handle_array().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ConnectResponse::Swap(ConnectResponse* other) {
+  if (other != this) {
+    std::swap(server_id_, other->server_id_);
+    std::swap(client_id_, other->client_id_);
+    std::swap(bind_result_, other->bind_result_);
+    std::swap(bind_response_, other->bind_response_);
+    std::swap(content_handle_array_, other->content_handle_array_);
+    std::swap(server_time_, other->server_time_);
+    std::swap(use_bindless_rpc_, other->use_bindless_rpc_);
+    std::swap(binary_content_handle_array_, other->binary_content_handle_array_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ConnectResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ConnectResponse_descriptor_;
+  metadata.reflection = ConnectResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int BoundService::kHashFieldNumber;
+const int BoundService::kIdFieldNumber;
+#endif  // !_MSC_VER
+
+BoundService::BoundService()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.BoundService)
+}
+
+void BoundService::InitAsDefaultInstance() {
+}
+
+BoundService::BoundService(const BoundService& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.BoundService)
+}
+
+void BoundService::SharedCtor() {
+  _cached_size_ = 0;
+  hash_ = 0u;
+  id_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+BoundService::~BoundService() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.BoundService)
+  SharedDtor();
+}
+
+void BoundService::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void BoundService::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* BoundService::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return BoundService_descriptor_;
+}
+
+const BoundService& BoundService::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto();
+  return *default_instance_;
+}
+
+BoundService* BoundService::default_instance_ = NULL;
+
+BoundService* BoundService::New() const {
+  return new BoundService;
+}
+
+void BoundService::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<BoundService*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(hash_, id_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool BoundService::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.BoundService)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required fixed32 hash = 1;
+      case 1: {
+        if (tag == 13) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &hash_)));
+          set_has_hash();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_id;
+        break;
+      }
+
+      // required uint32 id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.connection.v1.BoundService)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.BoundService)
+  return false;
+#undef DO_
+}
+
+void BoundService::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.BoundService)
+  // required fixed32 hash = 1;
+  if (has_hash()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->hash(), output);
+  }
+
+  // required uint32 id = 2;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.BoundService)
+}
+
+::google::protobuf::uint8* BoundService::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.BoundService)
+  // required fixed32 hash = 1;
+  if (has_hash()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->hash(), target);
+  }
+
+  // required uint32 id = 2;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.BoundService)
+  return target;
+}
+
+int BoundService::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required fixed32 hash = 1;
+    if (has_hash()) {
+      total_size += 1 + 4;
+    }
+
+    // required uint32 id = 2;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void BoundService::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const BoundService* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const BoundService*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void BoundService::MergeFrom(const BoundService& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_hash()) {
+      set_hash(from.hash());
+    }
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void BoundService::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void BoundService::CopyFrom(const BoundService& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BoundService::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  return true;
+}
+
+void BoundService::Swap(BoundService* other) {
+  if (other != this) {
+    std::swap(hash_, other->hash_);
+    std::swap(id_, other->id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata BoundService::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = BoundService_descriptor_;
+  metadata.reflection = BoundService_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int BindRequest::kDeprecatedImportedServiceHashFieldNumber;
+const int BindRequest::kDeprecatedExportedServiceFieldNumber;
+const int BindRequest::kExportedServiceFieldNumber;
+const int BindRequest::kImportedServiceFieldNumber;
+#endif  // !_MSC_VER
+
+BindRequest::BindRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.BindRequest)
+}
+
+void BindRequest::InitAsDefaultInstance() {
+}
+
+BindRequest::BindRequest(const BindRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.BindRequest)
+}
+
+void BindRequest::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+BindRequest::~BindRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.BindRequest)
+  SharedDtor();
+}
+
+void BindRequest::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void BindRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* BindRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return BindRequest_descriptor_;
+}
+
+const BindRequest& BindRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto();
+  return *default_instance_;
+}
+
+BindRequest* BindRequest::default_instance_ = NULL;
+
+BindRequest* BindRequest::New() const {
+  return new BindRequest;
+}
+
+void BindRequest::Clear() {
+  deprecated_imported_service_hash_.Clear();
+  deprecated_exported_service_.Clear();
+  exported_service_.Clear();
+  imported_service_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool BindRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.BindRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated fixed32 deprecated_imported_service_hash = 1 [packed = true, deprecated = true];
+      case 1: {
+        if (tag == 10) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, this->mutable_deprecated_imported_service_hash())));
+        } else if (tag == 13) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 1, 10, input, this->mutable_deprecated_imported_service_hash())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_deprecated_exported_service;
+        break;
+      }
+
+      // repeated .bgs.protocol.connection.v1.BoundService deprecated_exported_service = 2 [deprecated = true];
+      case 2: {
+        if (tag == 18) {
+         parse_deprecated_exported_service:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_deprecated_exported_service()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_deprecated_exported_service;
+        if (input->ExpectTag(26)) goto parse_exported_service;
+        break;
+      }
+
+      // repeated .bgs.protocol.connection.v1.BoundService exported_service = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_exported_service:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_exported_service()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_exported_service;
+        if (input->ExpectTag(34)) goto parse_imported_service;
+        break;
+      }
+
+      // repeated .bgs.protocol.connection.v1.BoundService imported_service = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_imported_service:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_imported_service()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_imported_service;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.connection.v1.BindRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.BindRequest)
+  return false;
+#undef DO_
+}
+
+void BindRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.BindRequest)
+  // repeated fixed32 deprecated_imported_service_hash = 1 [packed = true, deprecated = true];
+  if (this->deprecated_imported_service_hash_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_deprecated_imported_service_hash_cached_byte_size_);
+  }
+  for (int i = 0; i < this->deprecated_imported_service_hash_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32NoTag(
+      this->deprecated_imported_service_hash(i), output);
+  }
+
+  // repeated .bgs.protocol.connection.v1.BoundService deprecated_exported_service = 2 [deprecated = true];
+  for (int i = 0; i < this->deprecated_exported_service_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->deprecated_exported_service(i), output);
+  }
+
+  // repeated .bgs.protocol.connection.v1.BoundService exported_service = 3;
+  for (int i = 0; i < this->exported_service_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->exported_service(i), output);
+  }
+
+  // repeated .bgs.protocol.connection.v1.BoundService imported_service = 4;
+  for (int i = 0; i < this->imported_service_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->imported_service(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.BindRequest)
+}
+
+::google::protobuf::uint8* BindRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.BindRequest)
+  // repeated fixed32 deprecated_imported_service_hash = 1 [packed = true, deprecated = true];
+  if (this->deprecated_imported_service_hash_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      1,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _deprecated_imported_service_hash_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->deprecated_imported_service_hash_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteFixed32NoTagToArray(this->deprecated_imported_service_hash(i), target);
+  }
+
+  // repeated .bgs.protocol.connection.v1.BoundService deprecated_exported_service = 2 [deprecated = true];
+  for (int i = 0; i < this->deprecated_exported_service_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->deprecated_exported_service(i), target);
+  }
+
+  // repeated .bgs.protocol.connection.v1.BoundService exported_service = 3;
+  for (int i = 0; i < this->exported_service_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->exported_service(i), target);
+  }
+
+  // repeated .bgs.protocol.connection.v1.BoundService imported_service = 4;
+  for (int i = 0; i < this->imported_service_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->imported_service(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.BindRequest)
+  return target;
+}
+
+int BindRequest::ByteSize() const {
+  int total_size = 0;
+
+  // repeated fixed32 deprecated_imported_service_hash = 1 [packed = true, deprecated = true];
+  {
+    int data_size = 0;
+    data_size = 4 * this->deprecated_imported_service_hash_size();
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _deprecated_imported_service_hash_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated .bgs.protocol.connection.v1.BoundService deprecated_exported_service = 2 [deprecated = true];
+  total_size += 1 * this->deprecated_exported_service_size();
+  for (int i = 0; i < this->deprecated_exported_service_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->deprecated_exported_service(i));
+  }
+
+  // repeated .bgs.protocol.connection.v1.BoundService exported_service = 3;
+  total_size += 1 * this->exported_service_size();
+  for (int i = 0; i < this->exported_service_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->exported_service(i));
+  }
+
+  // repeated .bgs.protocol.connection.v1.BoundService imported_service = 4;
+  total_size += 1 * this->imported_service_size();
+  for (int i = 0; i < this->imported_service_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->imported_service(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void BindRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const BindRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const BindRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void BindRequest::MergeFrom(const BindRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  deprecated_imported_service_hash_.MergeFrom(from.deprecated_imported_service_hash_);
+  deprecated_exported_service_.MergeFrom(from.deprecated_exported_service_);
+  exported_service_.MergeFrom(from.exported_service_);
+  imported_service_.MergeFrom(from.imported_service_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void BindRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void BindRequest::CopyFrom(const BindRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BindRequest::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->deprecated_exported_service())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->exported_service())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->imported_service())) return false;
+  return true;
+}
+
+void BindRequest::Swap(BindRequest* other) {
+  if (other != this) {
+    deprecated_imported_service_hash_.Swap(&other->deprecated_imported_service_hash_);
+    deprecated_exported_service_.Swap(&other->deprecated_exported_service_);
+    exported_service_.Swap(&other->exported_service_);
+    imported_service_.Swap(&other->imported_service_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata BindRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = BindRequest_descriptor_;
+  metadata.reflection = BindRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int BindResponse::kImportedServiceIdFieldNumber;
+#endif  // !_MSC_VER
+
+BindResponse::BindResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.BindResponse)
+}
+
+void BindResponse::InitAsDefaultInstance() {
+}
+
+BindResponse::BindResponse(const BindResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.BindResponse)
+}
+
+void BindResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+BindResponse::~BindResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.BindResponse)
+  SharedDtor();
+}
+
+void BindResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void BindResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* BindResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return BindResponse_descriptor_;
+}
+
+const BindResponse& BindResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto();
+  return *default_instance_;
+}
+
+BindResponse* BindResponse::default_instance_ = NULL;
+
+BindResponse* BindResponse::New() const {
+  return new BindResponse;
+}
+
+void BindResponse::Clear() {
+  imported_service_id_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool BindResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.BindResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated uint32 imported_service_id = 1 [packed = true, deprecated = true];
+      case 1: {
+        if (tag == 10) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_imported_service_id())));
+        } else if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 10, input, this->mutable_imported_service_id())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.connection.v1.BindResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.BindResponse)
+  return false;
+#undef DO_
+}
+
+void BindResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.BindResponse)
+  // repeated uint32 imported_service_id = 1 [packed = true, deprecated = true];
+  if (this->imported_service_id_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(1, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_imported_service_id_cached_byte_size_);
+  }
+  for (int i = 0; i < this->imported_service_id_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->imported_service_id(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.BindResponse)
+}
+
+::google::protobuf::uint8* BindResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.BindResponse)
+  // repeated uint32 imported_service_id = 1 [packed = true, deprecated = true];
+  if (this->imported_service_id_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      1,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _imported_service_id_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->imported_service_id_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->imported_service_id(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.BindResponse)
+  return target;
+}
+
+int BindResponse::ByteSize() const {
+  int total_size = 0;
+
+  // repeated uint32 imported_service_id = 1 [packed = true, deprecated = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->imported_service_id_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->imported_service_id(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _imported_service_id_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void BindResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const BindResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const BindResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void BindResponse::MergeFrom(const BindResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  imported_service_id_.MergeFrom(from.imported_service_id_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void BindResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void BindResponse::CopyFrom(const BindResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BindResponse::IsInitialized() const {
+
+  return true;
+}
+
+void BindResponse::Swap(BindResponse* other) {
+  if (other != this) {
+    imported_service_id_.Swap(&other->imported_service_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata BindResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = BindResponse_descriptor_;
+  metadata.reflection = BindResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int EchoRequest::kTimeFieldNumber;
+const int EchoRequest::kNetworkOnlyFieldNumber;
+const int EchoRequest::kPayloadFieldNumber;
+#endif  // !_MSC_VER
+
+EchoRequest::EchoRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.EchoRequest)
+}
+
+void EchoRequest::InitAsDefaultInstance() {
+}
+
+EchoRequest::EchoRequest(const EchoRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.EchoRequest)
+}
+
+void EchoRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  time_ = GOOGLE_ULONGLONG(0);
+  network_only_ = false;
+  payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+EchoRequest::~EchoRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.EchoRequest)
+  SharedDtor();
+}
+
+void EchoRequest::SharedDtor() {
+  if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete payload_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void EchoRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* EchoRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return EchoRequest_descriptor_;
+}
+
+const EchoRequest& EchoRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto();
+  return *default_instance_;
+}
+
+EchoRequest* EchoRequest::default_instance_ = NULL;
+
+EchoRequest* EchoRequest::New() const {
+  return new EchoRequest;
+}
+
+void EchoRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    time_ = GOOGLE_ULONGLONG(0);
+    network_only_ = false;
+    if (has_payload()) {
+      if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        payload_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool EchoRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.EchoRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional fixed64 time = 1;
+      case 1: {
+        if (tag == 9) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &time_)));
+          set_has_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_network_only;
+        break;
+      }
+
+      // optional bool network_only = 2 [default = false];
+      case 2: {
+        if (tag == 16) {
+         parse_network_only:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &network_only_)));
+          set_has_network_only();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_payload;
+        break;
+      }
+
+      // optional bytes payload = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_payload:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_payload()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.connection.v1.EchoRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.EchoRequest)
+  return false;
+#undef DO_
+}
+
+void EchoRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.EchoRequest)
+  // optional fixed64 time = 1;
+  if (has_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->time(), output);
+  }
+
+  // optional bool network_only = 2 [default = false];
+  if (has_network_only()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->network_only(), output);
+  }
+
+  // optional bytes payload = 3;
+  if (has_payload()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      3, this->payload(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.EchoRequest)
+}
+
+::google::protobuf::uint8* EchoRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.EchoRequest)
+  // optional fixed64 time = 1;
+  if (has_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->time(), target);
+  }
+
+  // optional bool network_only = 2 [default = false];
+  if (has_network_only()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->network_only(), target);
+  }
+
+  // optional bytes payload = 3;
+  if (has_payload()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        3, this->payload(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.EchoRequest)
+  return target;
+}
+
+int EchoRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional fixed64 time = 1;
+    if (has_time()) {
+      total_size += 1 + 8;
+    }
+
+    // optional bool network_only = 2 [default = false];
+    if (has_network_only()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bytes payload = 3;
+    if (has_payload()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->payload());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void EchoRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const EchoRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const EchoRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void EchoRequest::MergeFrom(const EchoRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_time()) {
+      set_time(from.time());
+    }
+    if (from.has_network_only()) {
+      set_network_only(from.network_only());
+    }
+    if (from.has_payload()) {
+      set_payload(from.payload());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void EchoRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void EchoRequest::CopyFrom(const EchoRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool EchoRequest::IsInitialized() const {
+
+  return true;
+}
+
+void EchoRequest::Swap(EchoRequest* other) {
+  if (other != this) {
+    std::swap(time_, other->time_);
+    std::swap(network_only_, other->network_only_);
+    std::swap(payload_, other->payload_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata EchoRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = EchoRequest_descriptor_;
+  metadata.reflection = EchoRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int EchoResponse::kTimeFieldNumber;
+const int EchoResponse::kPayloadFieldNumber;
+#endif  // !_MSC_VER
+
+EchoResponse::EchoResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.EchoResponse)
+}
+
+void EchoResponse::InitAsDefaultInstance() {
+}
+
+EchoResponse::EchoResponse(const EchoResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.EchoResponse)
+}
+
+void EchoResponse::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  time_ = GOOGLE_ULONGLONG(0);
+  payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+EchoResponse::~EchoResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.EchoResponse)
+  SharedDtor();
+}
+
+void EchoResponse::SharedDtor() {
+  if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete payload_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void EchoResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* EchoResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return EchoResponse_descriptor_;
+}
+
+const EchoResponse& EchoResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto();
+  return *default_instance_;
+}
+
+EchoResponse* EchoResponse::default_instance_ = NULL;
+
+EchoResponse* EchoResponse::New() const {
+  return new EchoResponse;
+}
+
+void EchoResponse::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    time_ = GOOGLE_ULONGLONG(0);
+    if (has_payload()) {
+      if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        payload_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool EchoResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.EchoResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional fixed64 time = 1;
+      case 1: {
+        if (tag == 9) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &time_)));
+          set_has_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_payload;
+        break;
+      }
+
+      // optional bytes payload = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_payload:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_payload()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.connection.v1.EchoResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.EchoResponse)
+  return false;
+#undef DO_
+}
+
+void EchoResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.EchoResponse)
+  // optional fixed64 time = 1;
+  if (has_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->time(), output);
+  }
+
+  // optional bytes payload = 2;
+  if (has_payload()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      2, this->payload(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.EchoResponse)
+}
+
+::google::protobuf::uint8* EchoResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.EchoResponse)
+  // optional fixed64 time = 1;
+  if (has_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->time(), target);
+  }
+
+  // optional bytes payload = 2;
+  if (has_payload()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        2, this->payload(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.EchoResponse)
+  return target;
+}
+
+int EchoResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional fixed64 time = 1;
+    if (has_time()) {
+      total_size += 1 + 8;
+    }
+
+    // optional bytes payload = 2;
+    if (has_payload()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->payload());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void EchoResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const EchoResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const EchoResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void EchoResponse::MergeFrom(const EchoResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_time()) {
+      set_time(from.time());
+    }
+    if (from.has_payload()) {
+      set_payload(from.payload());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void EchoResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void EchoResponse::CopyFrom(const EchoResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool EchoResponse::IsInitialized() const {
+
+  return true;
+}
+
+void EchoResponse::Swap(EchoResponse* other) {
+  if (other != this) {
+    std::swap(time_, other->time_);
+    std::swap(payload_, other->payload_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata EchoResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = EchoResponse_descriptor_;
+  metadata.reflection = EchoResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int DisconnectRequest::kErrorCodeFieldNumber;
+#endif  // !_MSC_VER
+
+DisconnectRequest::DisconnectRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.DisconnectRequest)
+}
+
+void DisconnectRequest::InitAsDefaultInstance() {
+}
+
+DisconnectRequest::DisconnectRequest(const DisconnectRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.DisconnectRequest)
+}
+
+void DisconnectRequest::SharedCtor() {
+  _cached_size_ = 0;
+  error_code_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+DisconnectRequest::~DisconnectRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.DisconnectRequest)
+  SharedDtor();
+}
+
+void DisconnectRequest::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void DisconnectRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* DisconnectRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return DisconnectRequest_descriptor_;
+}
+
+const DisconnectRequest& DisconnectRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto();
+  return *default_instance_;
+}
+
+DisconnectRequest* DisconnectRequest::default_instance_ = NULL;
+
+DisconnectRequest* DisconnectRequest::New() const {
+  return new DisconnectRequest;
+}
+
+void DisconnectRequest::Clear() {
+  error_code_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool DisconnectRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.DisconnectRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required uint32 error_code = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &error_code_)));
+          set_has_error_code();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.connection.v1.DisconnectRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.DisconnectRequest)
+  return false;
+#undef DO_
+}
+
+void DisconnectRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.DisconnectRequest)
+  // required uint32 error_code = 1;
+  if (has_error_code()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->error_code(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.DisconnectRequest)
+}
+
+::google::protobuf::uint8* DisconnectRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.DisconnectRequest)
+  // required uint32 error_code = 1;
+  if (has_error_code()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->error_code(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.DisconnectRequest)
+  return target;
+}
+
+int DisconnectRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 error_code = 1;
+    if (has_error_code()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->error_code());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void DisconnectRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const DisconnectRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const DisconnectRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void DisconnectRequest::MergeFrom(const DisconnectRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_error_code()) {
+      set_error_code(from.error_code());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void DisconnectRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void DisconnectRequest::CopyFrom(const DisconnectRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DisconnectRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  return true;
+}
+
+void DisconnectRequest::Swap(DisconnectRequest* other) {
+  if (other != this) {
+    std::swap(error_code_, other->error_code_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata DisconnectRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = DisconnectRequest_descriptor_;
+  metadata.reflection = DisconnectRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int DisconnectNotification::kErrorCodeFieldNumber;
+const int DisconnectNotification::kReasonFieldNumber;
+#endif  // !_MSC_VER
+
+DisconnectNotification::DisconnectNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.DisconnectNotification)
+}
+
+void DisconnectNotification::InitAsDefaultInstance() {
+}
+
+DisconnectNotification::DisconnectNotification(const DisconnectNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.DisconnectNotification)
+}
+
+void DisconnectNotification::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  error_code_ = 0u;
+  reason_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+DisconnectNotification::~DisconnectNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.DisconnectNotification)
+  SharedDtor();
+}
+
+void DisconnectNotification::SharedDtor() {
+  if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete reason_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void DisconnectNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* DisconnectNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return DisconnectNotification_descriptor_;
+}
+
+const DisconnectNotification& DisconnectNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto();
+  return *default_instance_;
+}
+
+DisconnectNotification* DisconnectNotification::default_instance_ = NULL;
+
+DisconnectNotification* DisconnectNotification::New() const {
+  return new DisconnectNotification;
+}
+
+void DisconnectNotification::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    error_code_ = 0u;
+    if (has_reason()) {
+      if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        reason_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool DisconnectNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.DisconnectNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required uint32 error_code = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &error_code_)));
+          set_has_error_code();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_reason;
+        break;
+      }
+
+      // optional string reason = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_reason:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_reason()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->reason().data(), this->reason().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "reason");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.connection.v1.DisconnectNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.DisconnectNotification)
+  return false;
+#undef DO_
+}
+
+void DisconnectNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.DisconnectNotification)
+  // required uint32 error_code = 1;
+  if (has_error_code()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->error_code(), output);
+  }
+
+  // optional string reason = 2;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->reason().data(), this->reason().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "reason");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->reason(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.DisconnectNotification)
+}
+
+::google::protobuf::uint8* DisconnectNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.DisconnectNotification)
+  // required uint32 error_code = 1;
+  if (has_error_code()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->error_code(), target);
+  }
+
+  // optional string reason = 2;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->reason().data(), this->reason().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "reason");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->reason(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.DisconnectNotification)
+  return target;
+}
+
+int DisconnectNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 error_code = 1;
+    if (has_error_code()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->error_code());
+    }
+
+    // optional string reason = 2;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->reason());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void DisconnectNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const DisconnectNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const DisconnectNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void DisconnectNotification::MergeFrom(const DisconnectNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_error_code()) {
+      set_error_code(from.error_code());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void DisconnectNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void DisconnectNotification::CopyFrom(const DisconnectNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool DisconnectNotification::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  return true;
+}
+
+void DisconnectNotification::Swap(DisconnectNotification* other) {
+  if (other != this) {
+    std::swap(error_code_, other->error_code_);
+    std::swap(reason_, other->reason_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata DisconnectNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = DisconnectNotification_descriptor_;
+  metadata.reflection = DisconnectNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+#endif  // !_MSC_VER
+
+EncryptRequest::EncryptRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.connection.v1.EncryptRequest)
+}
+
+void EncryptRequest::InitAsDefaultInstance() {
+}
+
+EncryptRequest::EncryptRequest(const EncryptRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.connection.v1.EncryptRequest)
+}
+
+void EncryptRequest::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+EncryptRequest::~EncryptRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.connection.v1.EncryptRequest)
+  SharedDtor();
+}
+
+void EncryptRequest::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void EncryptRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* EncryptRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return EncryptRequest_descriptor_;
+}
+
+const EncryptRequest& EncryptRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_connection_5fservice_2eproto();
+  return *default_instance_;
+}
+
+EncryptRequest* EncryptRequest::default_instance_ = NULL;
+
+EncryptRequest* EncryptRequest::New() const {
+  return new EncryptRequest;
+}
+
+void EncryptRequest::Clear() {
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool EncryptRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.connection.v1.EncryptRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+  handle_unusual:
+    if (tag == 0 ||
+        ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+      goto success;
+    }
+    DO_(::google::protobuf::internal::WireFormat::SkipField(
+          input, tag, mutable_unknown_fields()));
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.connection.v1.EncryptRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.connection.v1.EncryptRequest)
+  return false;
+#undef DO_
+}
+
+void EncryptRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.connection.v1.EncryptRequest)
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.connection.v1.EncryptRequest)
+}
+
+::google::protobuf::uint8* EncryptRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.connection.v1.EncryptRequest)
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.connection.v1.EncryptRequest)
+  return target;
+}
+
+int EncryptRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void EncryptRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const EncryptRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const EncryptRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void EncryptRequest::MergeFrom(const EncryptRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void EncryptRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void EncryptRequest::CopyFrom(const EncryptRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool EncryptRequest::IsInitialized() const {
+
+  return true;
+}
+
+void EncryptRequest::Swap(EncryptRequest* other) {
+  if (other != this) {
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata EncryptRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = EncryptRequest_descriptor_;
+  metadata.reflection = EncryptRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* ConnectionService::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ConnectionService_descriptor_;
+}
+
+void ConnectionService::Connect(::bgs::protocol::connection::v1::ConnectRequest const* request, std::function<void(::bgs::protocol::connection::v1::ConnectResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ConnectionService.Connect(bgs.protocol.connection.v1.ConnectRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::connection::v1::ConnectResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ConnectionService::Bind(::bgs::protocol::connection::v1::BindRequest const* request, std::function<void(::bgs::protocol::connection::v1::BindResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ConnectionService.Bind(bgs.protocol.connection.v1.BindRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 2, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::connection::v1::BindResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ConnectionService::Echo(::bgs::protocol::connection::v1::EchoRequest const* request, std::function<void(::bgs::protocol::connection::v1::EchoResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ConnectionService.Echo(bgs.protocol.connection.v1.EchoRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 3, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::connection::v1::EchoResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ConnectionService::ForceDisconnect(::bgs::protocol::connection::v1::DisconnectNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ConnectionService.ForceDisconnect(bgs.protocol.connection.v1.DisconnectNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 4, request);
+}
+
+void ConnectionService::KeepAlive(::bgs::protocol::NoData const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ConnectionService.KeepAlive(bgs.protocol.NoData{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 5, request);
+}
+
+void ConnectionService::Encrypt(::bgs::protocol::connection::v1::EncryptRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ConnectionService.Encrypt(bgs.protocol.connection.v1.EncryptRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 6, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ConnectionService::RequestDisconnect(::bgs::protocol::connection::v1::DisconnectRequest const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ConnectionService.RequestDisconnect(bgs.protocol.connection.v1.DisconnectRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 7, request);
+}
+
+void ConnectionService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::connection::v1::ConnectRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ConnectionService.Connect server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::connection::v1::ConnectResponse response;
+      uint32 status = HandleConnect(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ConnectionService.Connect(bgs.protocol.connection.v1.ConnectRequest{ %s }) returned bgs.protocol.connection.v1.ConnectResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 1, token, &response);
+      else
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    case 2: {
+      ::bgs::protocol::connection::v1::BindRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ConnectionService.Bind server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::connection::v1::BindResponse response;
+      uint32 status = HandleBind(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ConnectionService.Bind(bgs.protocol.connection.v1.BindRequest{ %s }) returned bgs.protocol.connection.v1.BindResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 2, token, &response);
+      else
+        SendResponse(service_hash_, 2, token, status);
+      break;
+    }
+    case 3: {
+      ::bgs::protocol::connection::v1::EchoRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ConnectionService.Echo server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::connection::v1::EchoResponse response;
+      uint32 status = HandleEcho(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ConnectionService.Echo(bgs.protocol.connection.v1.EchoRequest{ %s }) returned bgs.protocol.connection.v1.EchoResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 3, token, &response);
+      else
+        SendResponse(service_hash_, 3, token, status);
+      break;
+    }
+    case 4: {
+      ::bgs::protocol::connection::v1::DisconnectNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ConnectionService.ForceDisconnect server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleForceDisconnect(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ConnectionService.ForceDisconnect(bgs.protocol.connection.v1.DisconnectNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 4, token, status);
+      break;
+    }
+    case 5: {
+      ::bgs::protocol::NoData request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ConnectionService.KeepAlive server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleKeepAlive(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ConnectionService.KeepAlive(bgs.protocol.NoData{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 5, token, status);
+      break;
+    }
+    case 6: {
+      ::bgs::protocol::connection::v1::EncryptRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ConnectionService.Encrypt server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleEncrypt(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ConnectionService.Encrypt(bgs.protocol.connection.v1.EncryptRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 6, token, &response);
+      else
+        SendResponse(service_hash_, 6, token, status);
+      break;
+    }
+    case 7: {
+      ::bgs::protocol::connection::v1::DisconnectRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ConnectionService.RequestDisconnect server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleRequestDisconnect(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ConnectionService.RequestDisconnect(bgs.protocol.connection.v1.DisconnectRequest{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 7, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 ConnectionService::HandleConnect(::bgs::protocol::connection::v1::ConnectRequest const* request, ::bgs::protocol::connection::v1::ConnectResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ConnectionService.Connect({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ConnectionService::HandleBind(::bgs::protocol::connection::v1::BindRequest const* request, ::bgs::protocol::connection::v1::BindResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ConnectionService.Bind({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ConnectionService::HandleEcho(::bgs::protocol::connection::v1::EchoRequest const* request, ::bgs::protocol::connection::v1::EchoResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ConnectionService.Echo({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ConnectionService::HandleForceDisconnect(::bgs::protocol::connection::v1::DisconnectNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ConnectionService.ForceDisconnect({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ConnectionService::HandleKeepAlive(::bgs::protocol::NoData const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ConnectionService.KeepAlive({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ConnectionService::HandleEncrypt(::bgs::protocol::connection::v1::EncryptRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ConnectionService.Encrypt({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 ConnectionService::HandleRequestDisconnect(::bgs::protocol::connection::v1::DisconnectRequest const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ConnectionService.RequestDisconnect({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace connection
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/connection_service.pb.h b/src/server/proto/Client/connection_service.pb.h
new file mode 100644
index 00000000000..0629391f5cf
--- /dev/null
+++ b/src/server/proto/Client/connection_service.pb.h
@@ -0,0 +1,2202 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: connection_service.proto
+
+#ifndef PROTOBUF_connection_5fservice_2eproto__INCLUDED
+#define PROTOBUF_connection_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 "content_handle_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 connection {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto();
+void protobuf_AssignDesc_connection_5fservice_2eproto();
+void protobuf_ShutdownFile_connection_5fservice_2eproto();
+
+class ConnectRequest;
+class ConnectionMeteringContentHandles;
+class ConnectResponse;
+class BoundService;
+class BindRequest;
+class BindResponse;
+class EchoRequest;
+class EchoResponse;
+class DisconnectRequest;
+class DisconnectNotification;
+class EncryptRequest;
+
+// ===================================================================
+
+class TC_SHARED_API ConnectRequest : public ::google::protobuf::Message {
+ public:
+  ConnectRequest();
+  virtual ~ConnectRequest();
+
+  ConnectRequest(const ConnectRequest& from);
+
+  inline ConnectRequest& operator=(const ConnectRequest& 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 ConnectRequest& default_instance();
+
+  void Swap(ConnectRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ConnectRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ConnectRequest& from);
+  void MergeFrom(const ConnectRequest& 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.ProcessId client_id = 1;
+  inline bool has_client_id() const;
+  inline void clear_client_id();
+  static const int kClientIdFieldNumber = 1;
+  inline const ::bgs::protocol::ProcessId& client_id() const;
+  inline ::bgs::protocol::ProcessId* mutable_client_id();
+  inline ::bgs::protocol::ProcessId* release_client_id();
+  inline void set_allocated_client_id(::bgs::protocol::ProcessId* client_id);
+
+  // optional .bgs.protocol.connection.v1.BindRequest bind_request = 2;
+  inline bool has_bind_request() const;
+  inline void clear_bind_request();
+  static const int kBindRequestFieldNumber = 2;
+  inline const ::bgs::protocol::connection::v1::BindRequest& bind_request() const;
+  inline ::bgs::protocol::connection::v1::BindRequest* mutable_bind_request();
+  inline ::bgs::protocol::connection::v1::BindRequest* release_bind_request();
+  inline void set_allocated_bind_request(::bgs::protocol::connection::v1::BindRequest* bind_request);
+
+  // optional bool use_bindless_rpc = 3 [default = true];
+  inline bool has_use_bindless_rpc() const;
+  inline void clear_use_bindless_rpc();
+  static const int kUseBindlessRpcFieldNumber = 3;
+  inline bool use_bindless_rpc() const;
+  inline void set_use_bindless_rpc(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.ConnectRequest)
+ private:
+  inline void set_has_client_id();
+  inline void clear_has_client_id();
+  inline void set_has_bind_request();
+  inline void clear_has_bind_request();
+  inline void set_has_use_bindless_rpc();
+  inline void clear_has_use_bindless_rpc();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::ProcessId* client_id_;
+  ::bgs::protocol::connection::v1::BindRequest* bind_request_;
+  bool use_bindless_rpc_;
+  friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto();
+  friend void protobuf_AssignDesc_connection_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_connection_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ConnectRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ConnectionMeteringContentHandles : public ::google::protobuf::Message {
+ public:
+  ConnectionMeteringContentHandles();
+  virtual ~ConnectionMeteringContentHandles();
+
+  ConnectionMeteringContentHandles(const ConnectionMeteringContentHandles& from);
+
+  inline ConnectionMeteringContentHandles& operator=(const ConnectionMeteringContentHandles& 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 ConnectionMeteringContentHandles& default_instance();
+
+  void Swap(ConnectionMeteringContentHandles* other);
+
+  // implements Message ----------------------------------------------
+
+  ConnectionMeteringContentHandles* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ConnectionMeteringContentHandles& from);
+  void MergeFrom(const ConnectionMeteringContentHandles& 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.ContentHandle content_handle = 1;
+  inline int content_handle_size() const;
+  inline void clear_content_handle();
+  static const int kContentHandleFieldNumber = 1;
+  inline const ::bgs::protocol::ContentHandle& content_handle(int index) const;
+  inline ::bgs::protocol::ContentHandle* mutable_content_handle(int index);
+  inline ::bgs::protocol::ContentHandle* add_content_handle();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ContentHandle >&
+      content_handle() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ContentHandle >*
+      mutable_content_handle();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.ConnectionMeteringContentHandles)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ContentHandle > content_handle_;
+  friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto();
+  friend void protobuf_AssignDesc_connection_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_connection_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ConnectionMeteringContentHandles* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ConnectResponse : public ::google::protobuf::Message {
+ public:
+  ConnectResponse();
+  virtual ~ConnectResponse();
+
+  ConnectResponse(const ConnectResponse& from);
+
+  inline ConnectResponse& operator=(const ConnectResponse& 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 ConnectResponse& default_instance();
+
+  void Swap(ConnectResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  ConnectResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ConnectResponse& from);
+  void MergeFrom(const ConnectResponse& 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.ProcessId server_id = 1;
+  inline bool has_server_id() const;
+  inline void clear_server_id();
+  static const int kServerIdFieldNumber = 1;
+  inline const ::bgs::protocol::ProcessId& server_id() const;
+  inline ::bgs::protocol::ProcessId* mutable_server_id();
+  inline ::bgs::protocol::ProcessId* release_server_id();
+  inline void set_allocated_server_id(::bgs::protocol::ProcessId* server_id);
+
+  // optional .bgs.protocol.ProcessId client_id = 2;
+  inline bool has_client_id() const;
+  inline void clear_client_id();
+  static const int kClientIdFieldNumber = 2;
+  inline const ::bgs::protocol::ProcessId& client_id() const;
+  inline ::bgs::protocol::ProcessId* mutable_client_id();
+  inline ::bgs::protocol::ProcessId* release_client_id();
+  inline void set_allocated_client_id(::bgs::protocol::ProcessId* client_id);
+
+  // optional uint32 bind_result = 3;
+  inline bool has_bind_result() const;
+  inline void clear_bind_result();
+  static const int kBindResultFieldNumber = 3;
+  inline ::google::protobuf::uint32 bind_result() const;
+  inline void set_bind_result(::google::protobuf::uint32 value);
+
+  // optional .bgs.protocol.connection.v1.BindResponse bind_response = 4;
+  inline bool has_bind_response() const;
+  inline void clear_bind_response();
+  static const int kBindResponseFieldNumber = 4;
+  inline const ::bgs::protocol::connection::v1::BindResponse& bind_response() const;
+  inline ::bgs::protocol::connection::v1::BindResponse* mutable_bind_response();
+  inline ::bgs::protocol::connection::v1::BindResponse* release_bind_response();
+  inline void set_allocated_bind_response(::bgs::protocol::connection::v1::BindResponse* bind_response);
+
+  // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles content_handle_array = 5;
+  inline bool has_content_handle_array() const;
+  inline void clear_content_handle_array();
+  static const int kContentHandleArrayFieldNumber = 5;
+  inline const ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles& content_handle_array() const;
+  inline ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* mutable_content_handle_array();
+  inline ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* release_content_handle_array();
+  inline void set_allocated_content_handle_array(::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* content_handle_array);
+
+  // optional uint64 server_time = 6;
+  inline bool has_server_time() const;
+  inline void clear_server_time();
+  static const int kServerTimeFieldNumber = 6;
+  inline ::google::protobuf::uint64 server_time() const;
+  inline void set_server_time(::google::protobuf::uint64 value);
+
+  // optional bool use_bindless_rpc = 7 [default = false];
+  inline bool has_use_bindless_rpc() const;
+  inline void clear_use_bindless_rpc();
+  static const int kUseBindlessRpcFieldNumber = 7;
+  inline bool use_bindless_rpc() const;
+  inline void set_use_bindless_rpc(bool value);
+
+  // optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles binary_content_handle_array = 8;
+  inline bool has_binary_content_handle_array() const;
+  inline void clear_binary_content_handle_array();
+  static const int kBinaryContentHandleArrayFieldNumber = 8;
+  inline const ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles& binary_content_handle_array() const;
+  inline ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* mutable_binary_content_handle_array();
+  inline ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* release_binary_content_handle_array();
+  inline void set_allocated_binary_content_handle_array(::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* binary_content_handle_array);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.ConnectResponse)
+ private:
+  inline void set_has_server_id();
+  inline void clear_has_server_id();
+  inline void set_has_client_id();
+  inline void clear_has_client_id();
+  inline void set_has_bind_result();
+  inline void clear_has_bind_result();
+  inline void set_has_bind_response();
+  inline void clear_has_bind_response();
+  inline void set_has_content_handle_array();
+  inline void clear_has_content_handle_array();
+  inline void set_has_server_time();
+  inline void clear_has_server_time();
+  inline void set_has_use_bindless_rpc();
+  inline void clear_has_use_bindless_rpc();
+  inline void set_has_binary_content_handle_array();
+  inline void clear_has_binary_content_handle_array();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::ProcessId* server_id_;
+  ::bgs::protocol::ProcessId* client_id_;
+  ::bgs::protocol::connection::v1::BindResponse* bind_response_;
+  ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* content_handle_array_;
+  ::google::protobuf::uint32 bind_result_;
+  bool use_bindless_rpc_;
+  ::google::protobuf::uint64 server_time_;
+  ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* binary_content_handle_array_;
+  friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto();
+  friend void protobuf_AssignDesc_connection_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_connection_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ConnectResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API BoundService : public ::google::protobuf::Message {
+ public:
+  BoundService();
+  virtual ~BoundService();
+
+  BoundService(const BoundService& from);
+
+  inline BoundService& operator=(const BoundService& 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 BoundService& default_instance();
+
+  void Swap(BoundService* other);
+
+  // implements Message ----------------------------------------------
+
+  BoundService* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const BoundService& from);
+  void MergeFrom(const BoundService& 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 fixed32 hash = 1;
+  inline bool has_hash() const;
+  inline void clear_hash();
+  static const int kHashFieldNumber = 1;
+  inline ::google::protobuf::uint32 hash() const;
+  inline void set_hash(::google::protobuf::uint32 value);
+
+  // required uint32 id = 2;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 2;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.BoundService)
+ private:
+  inline void set_has_hash();
+  inline void clear_has_hash();
+  inline void set_has_id();
+  inline void clear_has_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 hash_;
+  ::google::protobuf::uint32 id_;
+  friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto();
+  friend void protobuf_AssignDesc_connection_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_connection_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static BoundService* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API BindRequest : public ::google::protobuf::Message {
+ public:
+  BindRequest();
+  virtual ~BindRequest();
+
+  BindRequest(const BindRequest& from);
+
+  inline BindRequest& operator=(const BindRequest& 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 BindRequest& default_instance();
+
+  void Swap(BindRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  BindRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const BindRequest& from);
+  void MergeFrom(const BindRequest& 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 fixed32 deprecated_imported_service_hash = 1 [packed = true, deprecated = true];
+  inline int deprecated_imported_service_hash_size() const PROTOBUF_DEPRECATED;
+  inline void clear_deprecated_imported_service_hash() PROTOBUF_DEPRECATED;
+  static const int kDeprecatedImportedServiceHashFieldNumber = 1;
+  inline ::google::protobuf::uint32 deprecated_imported_service_hash(int index) const PROTOBUF_DEPRECATED;
+  inline void set_deprecated_imported_service_hash(int index, ::google::protobuf::uint32 value) PROTOBUF_DEPRECATED;
+  inline void add_deprecated_imported_service_hash(::google::protobuf::uint32 value) PROTOBUF_DEPRECATED;
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      deprecated_imported_service_hash() const PROTOBUF_DEPRECATED;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_deprecated_imported_service_hash() PROTOBUF_DEPRECATED;
+
+  // repeated .bgs.protocol.connection.v1.BoundService deprecated_exported_service = 2 [deprecated = true];
+  inline int deprecated_exported_service_size() const PROTOBUF_DEPRECATED;
+  inline void clear_deprecated_exported_service() PROTOBUF_DEPRECATED;
+  static const int kDeprecatedExportedServiceFieldNumber = 2;
+  inline const ::bgs::protocol::connection::v1::BoundService& deprecated_exported_service(int index) const PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::connection::v1::BoundService* mutable_deprecated_exported_service(int index) PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::connection::v1::BoundService* add_deprecated_exported_service() PROTOBUF_DEPRECATED;
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >&
+      deprecated_exported_service() const PROTOBUF_DEPRECATED;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >*
+      mutable_deprecated_exported_service() PROTOBUF_DEPRECATED;
+
+  // repeated .bgs.protocol.connection.v1.BoundService exported_service = 3;
+  inline int exported_service_size() const;
+  inline void clear_exported_service();
+  static const int kExportedServiceFieldNumber = 3;
+  inline const ::bgs::protocol::connection::v1::BoundService& exported_service(int index) const;
+  inline ::bgs::protocol::connection::v1::BoundService* mutable_exported_service(int index);
+  inline ::bgs::protocol::connection::v1::BoundService* add_exported_service();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >&
+      exported_service() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >*
+      mutable_exported_service();
+
+  // repeated .bgs.protocol.connection.v1.BoundService imported_service = 4;
+  inline int imported_service_size() const;
+  inline void clear_imported_service();
+  static const int kImportedServiceFieldNumber = 4;
+  inline const ::bgs::protocol::connection::v1::BoundService& imported_service(int index) const;
+  inline ::bgs::protocol::connection::v1::BoundService* mutable_imported_service(int index);
+  inline ::bgs::protocol::connection::v1::BoundService* add_imported_service();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >&
+      imported_service() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >*
+      mutable_imported_service();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.BindRequest)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > deprecated_imported_service_hash_;
+  mutable int _deprecated_imported_service_hash_cached_byte_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService > deprecated_exported_service_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService > exported_service_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService > imported_service_;
+  friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto();
+  friend void protobuf_AssignDesc_connection_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_connection_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static BindRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API BindResponse : public ::google::protobuf::Message {
+ public:
+  BindResponse();
+  virtual ~BindResponse();
+
+  BindResponse(const BindResponse& from);
+
+  inline BindResponse& operator=(const BindResponse& 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 BindResponse& default_instance();
+
+  void Swap(BindResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  BindResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const BindResponse& from);
+  void MergeFrom(const BindResponse& 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 uint32 imported_service_id = 1 [packed = true, deprecated = true];
+  inline int imported_service_id_size() const PROTOBUF_DEPRECATED;
+  inline void clear_imported_service_id() PROTOBUF_DEPRECATED;
+  static const int kImportedServiceIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 imported_service_id(int index) const PROTOBUF_DEPRECATED;
+  inline void set_imported_service_id(int index, ::google::protobuf::uint32 value) PROTOBUF_DEPRECATED;
+  inline void add_imported_service_id(::google::protobuf::uint32 value) PROTOBUF_DEPRECATED;
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      imported_service_id() const PROTOBUF_DEPRECATED;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_imported_service_id() PROTOBUF_DEPRECATED;
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.BindResponse)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > imported_service_id_;
+  mutable int _imported_service_id_cached_byte_size_;
+  friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto();
+  friend void protobuf_AssignDesc_connection_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_connection_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static BindResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API EchoRequest : public ::google::protobuf::Message {
+ public:
+  EchoRequest();
+  virtual ~EchoRequest();
+
+  EchoRequest(const EchoRequest& from);
+
+  inline EchoRequest& operator=(const EchoRequest& 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 EchoRequest& default_instance();
+
+  void Swap(EchoRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  EchoRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const EchoRequest& from);
+  void MergeFrom(const EchoRequest& 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 fixed64 time = 1;
+  inline bool has_time() const;
+  inline void clear_time();
+  static const int kTimeFieldNumber = 1;
+  inline ::google::protobuf::uint64 time() const;
+  inline void set_time(::google::protobuf::uint64 value);
+
+  // optional bool network_only = 2 [default = false];
+  inline bool has_network_only() const;
+  inline void clear_network_only();
+  static const int kNetworkOnlyFieldNumber = 2;
+  inline bool network_only() const;
+  inline void set_network_only(bool value);
+
+  // optional bytes payload = 3;
+  inline bool has_payload() const;
+  inline void clear_payload();
+  static const int kPayloadFieldNumber = 3;
+  inline const ::std::string& payload() const;
+  inline void set_payload(const ::std::string& value);
+  inline void set_payload(const char* value);
+  inline void set_payload(const void* value, size_t size);
+  inline ::std::string* mutable_payload();
+  inline ::std::string* release_payload();
+  inline void set_allocated_payload(::std::string* payload);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.EchoRequest)
+ private:
+  inline void set_has_time();
+  inline void clear_has_time();
+  inline void set_has_network_only();
+  inline void clear_has_network_only();
+  inline void set_has_payload();
+  inline void clear_has_payload();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 time_;
+  ::std::string* payload_;
+  bool network_only_;
+  friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto();
+  friend void protobuf_AssignDesc_connection_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_connection_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static EchoRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API EchoResponse : public ::google::protobuf::Message {
+ public:
+  EchoResponse();
+  virtual ~EchoResponse();
+
+  EchoResponse(const EchoResponse& from);
+
+  inline EchoResponse& operator=(const EchoResponse& 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 EchoResponse& default_instance();
+
+  void Swap(EchoResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  EchoResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const EchoResponse& from);
+  void MergeFrom(const EchoResponse& 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 fixed64 time = 1;
+  inline bool has_time() const;
+  inline void clear_time();
+  static const int kTimeFieldNumber = 1;
+  inline ::google::protobuf::uint64 time() const;
+  inline void set_time(::google::protobuf::uint64 value);
+
+  // optional bytes payload = 2;
+  inline bool has_payload() const;
+  inline void clear_payload();
+  static const int kPayloadFieldNumber = 2;
+  inline const ::std::string& payload() const;
+  inline void set_payload(const ::std::string& value);
+  inline void set_payload(const char* value);
+  inline void set_payload(const void* value, size_t size);
+  inline ::std::string* mutable_payload();
+  inline ::std::string* release_payload();
+  inline void set_allocated_payload(::std::string* payload);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.EchoResponse)
+ private:
+  inline void set_has_time();
+  inline void clear_has_time();
+  inline void set_has_payload();
+  inline void clear_has_payload();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 time_;
+  ::std::string* payload_;
+  friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto();
+  friend void protobuf_AssignDesc_connection_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_connection_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static EchoResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API DisconnectRequest : public ::google::protobuf::Message {
+ public:
+  DisconnectRequest();
+  virtual ~DisconnectRequest();
+
+  DisconnectRequest(const DisconnectRequest& from);
+
+  inline DisconnectRequest& operator=(const DisconnectRequest& 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 DisconnectRequest& default_instance();
+
+  void Swap(DisconnectRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  DisconnectRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const DisconnectRequest& from);
+  void MergeFrom(const DisconnectRequest& 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.connection.v1.DisconnectRequest)
+ 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_connection_5fservice_2eproto();
+  friend void protobuf_AssignDesc_connection_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_connection_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static DisconnectRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API DisconnectNotification : public ::google::protobuf::Message {
+ public:
+  DisconnectNotification();
+  virtual ~DisconnectNotification();
+
+  DisconnectNotification(const DisconnectNotification& from);
+
+  inline DisconnectNotification& operator=(const DisconnectNotification& 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 DisconnectNotification& default_instance();
+
+  void Swap(DisconnectNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  DisconnectNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const DisconnectNotification& from);
+  void MergeFrom(const DisconnectNotification& 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 string reason = 2;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 2;
+  inline const ::std::string& reason() const;
+  inline void set_reason(const ::std::string& value);
+  inline void set_reason(const char* value);
+  inline void set_reason(const char* value, size_t size);
+  inline ::std::string* mutable_reason();
+  inline ::std::string* release_reason();
+  inline void set_allocated_reason(::std::string* reason);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.DisconnectNotification)
+ private:
+  inline void set_has_error_code();
+  inline void clear_has_error_code();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* reason_;
+  ::google::protobuf::uint32 error_code_;
+  friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto();
+  friend void protobuf_AssignDesc_connection_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_connection_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static DisconnectNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API EncryptRequest : public ::google::protobuf::Message {
+ public:
+  EncryptRequest();
+  virtual ~EncryptRequest();
+
+  EncryptRequest(const EncryptRequest& from);
+
+  inline EncryptRequest& operator=(const EncryptRequest& 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 EncryptRequest& default_instance();
+
+  void Swap(EncryptRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  EncryptRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const EncryptRequest& from);
+  void MergeFrom(const EncryptRequest& 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 -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.connection.v1.EncryptRequest)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  friend void TC_SHARED_API protobuf_AddDesc_connection_5fservice_2eproto();
+  friend void protobuf_AssignDesc_connection_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_connection_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static EncryptRequest* default_instance_;
+};
+// ===================================================================
+
+class TC_SHARED_API ConnectionService : public ServiceBase
+{
+ public:
+
+  template<typename HashSelector>
+  explicit ConnectionService(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  typedef std::integral_constant<uint32, 0x65446991u> OriginalHash;
+  typedef std::integral_constant<uint32, 0x2782094Bu> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void Connect(::bgs::protocol::connection::v1::ConnectRequest const* request, std::function<void(::bgs::protocol::connection::v1::ConnectResponse const*)> responseCallback);
+  void Bind(::bgs::protocol::connection::v1::BindRequest const* request, std::function<void(::bgs::protocol::connection::v1::BindResponse const*)> responseCallback);
+  void Echo(::bgs::protocol::connection::v1::EchoRequest const* request, std::function<void(::bgs::protocol::connection::v1::EchoResponse const*)> responseCallback);
+  void ForceDisconnect(::bgs::protocol::connection::v1::DisconnectNotification const* request);
+  void KeepAlive(::bgs::protocol::NoData const* request);
+  void Encrypt(::bgs::protocol::connection::v1::EncryptRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void RequestDisconnect(::bgs::protocol::connection::v1::DisconnectRequest const* request);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleConnect(::bgs::protocol::connection::v1::ConnectRequest const* request, ::bgs::protocol::connection::v1::ConnectResponse* response);
+  virtual uint32 HandleBind(::bgs::protocol::connection::v1::BindRequest const* request, ::bgs::protocol::connection::v1::BindResponse* response);
+  virtual uint32 HandleEcho(::bgs::protocol::connection::v1::EchoRequest const* request, ::bgs::protocol::connection::v1::EchoResponse* response);
+  virtual uint32 HandleForceDisconnect(::bgs::protocol::connection::v1::DisconnectNotification const* request);
+  virtual uint32 HandleKeepAlive(::bgs::protocol::NoData const* request);
+  virtual uint32 HandleEncrypt(::bgs::protocol::connection::v1::EncryptRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleRequestDisconnect(::bgs::protocol::connection::v1::DisconnectRequest const* request);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ConnectionService);
+};
+
+// ===================================================================
+
+
+// ===================================================================
+
+// ConnectRequest
+
+// optional .bgs.protocol.ProcessId client_id = 1;
+inline bool ConnectRequest::has_client_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ConnectRequest::set_has_client_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ConnectRequest::clear_has_client_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ConnectRequest::clear_client_id() {
+  if (client_id_ != NULL) client_id_->::bgs::protocol::ProcessId::Clear();
+  clear_has_client_id();
+}
+inline const ::bgs::protocol::ProcessId& ConnectRequest::client_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectRequest.client_id)
+  return client_id_ != NULL ? *client_id_ : *default_instance_->client_id_;
+}
+inline ::bgs::protocol::ProcessId* ConnectRequest::mutable_client_id() {
+  set_has_client_id();
+  if (client_id_ == NULL) client_id_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.ConnectRequest.client_id)
+  return client_id_;
+}
+inline ::bgs::protocol::ProcessId* ConnectRequest::release_client_id() {
+  clear_has_client_id();
+  ::bgs::protocol::ProcessId* temp = client_id_;
+  client_id_ = NULL;
+  return temp;
+}
+inline void ConnectRequest::set_allocated_client_id(::bgs::protocol::ProcessId* client_id) {
+  delete client_id_;
+  client_id_ = client_id;
+  if (client_id) {
+    set_has_client_id();
+  } else {
+    clear_has_client_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.ConnectRequest.client_id)
+}
+
+// optional .bgs.protocol.connection.v1.BindRequest bind_request = 2;
+inline bool ConnectRequest::has_bind_request() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ConnectRequest::set_has_bind_request() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ConnectRequest::clear_has_bind_request() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ConnectRequest::clear_bind_request() {
+  if (bind_request_ != NULL) bind_request_->::bgs::protocol::connection::v1::BindRequest::Clear();
+  clear_has_bind_request();
+}
+inline const ::bgs::protocol::connection::v1::BindRequest& ConnectRequest::bind_request() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectRequest.bind_request)
+  return bind_request_ != NULL ? *bind_request_ : *default_instance_->bind_request_;
+}
+inline ::bgs::protocol::connection::v1::BindRequest* ConnectRequest::mutable_bind_request() {
+  set_has_bind_request();
+  if (bind_request_ == NULL) bind_request_ = new ::bgs::protocol::connection::v1::BindRequest;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.ConnectRequest.bind_request)
+  return bind_request_;
+}
+inline ::bgs::protocol::connection::v1::BindRequest* ConnectRequest::release_bind_request() {
+  clear_has_bind_request();
+  ::bgs::protocol::connection::v1::BindRequest* temp = bind_request_;
+  bind_request_ = NULL;
+  return temp;
+}
+inline void ConnectRequest::set_allocated_bind_request(::bgs::protocol::connection::v1::BindRequest* bind_request) {
+  delete bind_request_;
+  bind_request_ = bind_request;
+  if (bind_request) {
+    set_has_bind_request();
+  } else {
+    clear_has_bind_request();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.ConnectRequest.bind_request)
+}
+
+// optional bool use_bindless_rpc = 3 [default = true];
+inline bool ConnectRequest::has_use_bindless_rpc() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ConnectRequest::set_has_use_bindless_rpc() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ConnectRequest::clear_has_use_bindless_rpc() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ConnectRequest::clear_use_bindless_rpc() {
+  use_bindless_rpc_ = true;
+  clear_has_use_bindless_rpc();
+}
+inline bool ConnectRequest::use_bindless_rpc() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectRequest.use_bindless_rpc)
+  return use_bindless_rpc_;
+}
+inline void ConnectRequest::set_use_bindless_rpc(bool value) {
+  set_has_use_bindless_rpc();
+  use_bindless_rpc_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.ConnectRequest.use_bindless_rpc)
+}
+
+// -------------------------------------------------------------------
+
+// ConnectionMeteringContentHandles
+
+// repeated .bgs.protocol.ContentHandle content_handle = 1;
+inline int ConnectionMeteringContentHandles::content_handle_size() const {
+  return content_handle_.size();
+}
+inline void ConnectionMeteringContentHandles::clear_content_handle() {
+  content_handle_.Clear();
+}
+inline const ::bgs::protocol::ContentHandle& ConnectionMeteringContentHandles::content_handle(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectionMeteringContentHandles.content_handle)
+  return content_handle_.Get(index);
+}
+inline ::bgs::protocol::ContentHandle* ConnectionMeteringContentHandles::mutable_content_handle(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.ConnectionMeteringContentHandles.content_handle)
+  return content_handle_.Mutable(index);
+}
+inline ::bgs::protocol::ContentHandle* ConnectionMeteringContentHandles::add_content_handle() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.connection.v1.ConnectionMeteringContentHandles.content_handle)
+  return content_handle_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ContentHandle >&
+ConnectionMeteringContentHandles::content_handle() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.connection.v1.ConnectionMeteringContentHandles.content_handle)
+  return content_handle_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ContentHandle >*
+ConnectionMeteringContentHandles::mutable_content_handle() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.connection.v1.ConnectionMeteringContentHandles.content_handle)
+  return &content_handle_;
+}
+
+// -------------------------------------------------------------------
+
+// ConnectResponse
+
+// required .bgs.protocol.ProcessId server_id = 1;
+inline bool ConnectResponse::has_server_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ConnectResponse::set_has_server_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ConnectResponse::clear_has_server_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ConnectResponse::clear_server_id() {
+  if (server_id_ != NULL) server_id_->::bgs::protocol::ProcessId::Clear();
+  clear_has_server_id();
+}
+inline const ::bgs::protocol::ProcessId& ConnectResponse::server_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectResponse.server_id)
+  return server_id_ != NULL ? *server_id_ : *default_instance_->server_id_;
+}
+inline ::bgs::protocol::ProcessId* ConnectResponse::mutable_server_id() {
+  set_has_server_id();
+  if (server_id_ == NULL) server_id_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.ConnectResponse.server_id)
+  return server_id_;
+}
+inline ::bgs::protocol::ProcessId* ConnectResponse::release_server_id() {
+  clear_has_server_id();
+  ::bgs::protocol::ProcessId* temp = server_id_;
+  server_id_ = NULL;
+  return temp;
+}
+inline void ConnectResponse::set_allocated_server_id(::bgs::protocol::ProcessId* server_id) {
+  delete server_id_;
+  server_id_ = server_id;
+  if (server_id) {
+    set_has_server_id();
+  } else {
+    clear_has_server_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.ConnectResponse.server_id)
+}
+
+// optional .bgs.protocol.ProcessId client_id = 2;
+inline bool ConnectResponse::has_client_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ConnectResponse::set_has_client_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ConnectResponse::clear_has_client_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ConnectResponse::clear_client_id() {
+  if (client_id_ != NULL) client_id_->::bgs::protocol::ProcessId::Clear();
+  clear_has_client_id();
+}
+inline const ::bgs::protocol::ProcessId& ConnectResponse::client_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectResponse.client_id)
+  return client_id_ != NULL ? *client_id_ : *default_instance_->client_id_;
+}
+inline ::bgs::protocol::ProcessId* ConnectResponse::mutable_client_id() {
+  set_has_client_id();
+  if (client_id_ == NULL) client_id_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.ConnectResponse.client_id)
+  return client_id_;
+}
+inline ::bgs::protocol::ProcessId* ConnectResponse::release_client_id() {
+  clear_has_client_id();
+  ::bgs::protocol::ProcessId* temp = client_id_;
+  client_id_ = NULL;
+  return temp;
+}
+inline void ConnectResponse::set_allocated_client_id(::bgs::protocol::ProcessId* client_id) {
+  delete client_id_;
+  client_id_ = client_id;
+  if (client_id) {
+    set_has_client_id();
+  } else {
+    clear_has_client_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.ConnectResponse.client_id)
+}
+
+// optional uint32 bind_result = 3;
+inline bool ConnectResponse::has_bind_result() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ConnectResponse::set_has_bind_result() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ConnectResponse::clear_has_bind_result() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ConnectResponse::clear_bind_result() {
+  bind_result_ = 0u;
+  clear_has_bind_result();
+}
+inline ::google::protobuf::uint32 ConnectResponse::bind_result() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectResponse.bind_result)
+  return bind_result_;
+}
+inline void ConnectResponse::set_bind_result(::google::protobuf::uint32 value) {
+  set_has_bind_result();
+  bind_result_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.ConnectResponse.bind_result)
+}
+
+// optional .bgs.protocol.connection.v1.BindResponse bind_response = 4;
+inline bool ConnectResponse::has_bind_response() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ConnectResponse::set_has_bind_response() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ConnectResponse::clear_has_bind_response() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ConnectResponse::clear_bind_response() {
+  if (bind_response_ != NULL) bind_response_->::bgs::protocol::connection::v1::BindResponse::Clear();
+  clear_has_bind_response();
+}
+inline const ::bgs::protocol::connection::v1::BindResponse& ConnectResponse::bind_response() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectResponse.bind_response)
+  return bind_response_ != NULL ? *bind_response_ : *default_instance_->bind_response_;
+}
+inline ::bgs::protocol::connection::v1::BindResponse* ConnectResponse::mutable_bind_response() {
+  set_has_bind_response();
+  if (bind_response_ == NULL) bind_response_ = new ::bgs::protocol::connection::v1::BindResponse;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.ConnectResponse.bind_response)
+  return bind_response_;
+}
+inline ::bgs::protocol::connection::v1::BindResponse* ConnectResponse::release_bind_response() {
+  clear_has_bind_response();
+  ::bgs::protocol::connection::v1::BindResponse* temp = bind_response_;
+  bind_response_ = NULL;
+  return temp;
+}
+inline void ConnectResponse::set_allocated_bind_response(::bgs::protocol::connection::v1::BindResponse* bind_response) {
+  delete bind_response_;
+  bind_response_ = bind_response;
+  if (bind_response) {
+    set_has_bind_response();
+  } else {
+    clear_has_bind_response();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.ConnectResponse.bind_response)
+}
+
+// optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles content_handle_array = 5;
+inline bool ConnectResponse::has_content_handle_array() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ConnectResponse::set_has_content_handle_array() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ConnectResponse::clear_has_content_handle_array() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ConnectResponse::clear_content_handle_array() {
+  if (content_handle_array_ != NULL) content_handle_array_->::bgs::protocol::connection::v1::ConnectionMeteringContentHandles::Clear();
+  clear_has_content_handle_array();
+}
+inline const ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles& ConnectResponse::content_handle_array() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectResponse.content_handle_array)
+  return content_handle_array_ != NULL ? *content_handle_array_ : *default_instance_->content_handle_array_;
+}
+inline ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* ConnectResponse::mutable_content_handle_array() {
+  set_has_content_handle_array();
+  if (content_handle_array_ == NULL) content_handle_array_ = new ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.ConnectResponse.content_handle_array)
+  return content_handle_array_;
+}
+inline ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* ConnectResponse::release_content_handle_array() {
+  clear_has_content_handle_array();
+  ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* temp = content_handle_array_;
+  content_handle_array_ = NULL;
+  return temp;
+}
+inline void ConnectResponse::set_allocated_content_handle_array(::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* content_handle_array) {
+  delete content_handle_array_;
+  content_handle_array_ = content_handle_array;
+  if (content_handle_array) {
+    set_has_content_handle_array();
+  } else {
+    clear_has_content_handle_array();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.ConnectResponse.content_handle_array)
+}
+
+// optional uint64 server_time = 6;
+inline bool ConnectResponse::has_server_time() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ConnectResponse::set_has_server_time() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ConnectResponse::clear_has_server_time() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ConnectResponse::clear_server_time() {
+  server_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_server_time();
+}
+inline ::google::protobuf::uint64 ConnectResponse::server_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectResponse.server_time)
+  return server_time_;
+}
+inline void ConnectResponse::set_server_time(::google::protobuf::uint64 value) {
+  set_has_server_time();
+  server_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.ConnectResponse.server_time)
+}
+
+// optional bool use_bindless_rpc = 7 [default = false];
+inline bool ConnectResponse::has_use_bindless_rpc() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void ConnectResponse::set_has_use_bindless_rpc() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void ConnectResponse::clear_has_use_bindless_rpc() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void ConnectResponse::clear_use_bindless_rpc() {
+  use_bindless_rpc_ = false;
+  clear_has_use_bindless_rpc();
+}
+inline bool ConnectResponse::use_bindless_rpc() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectResponse.use_bindless_rpc)
+  return use_bindless_rpc_;
+}
+inline void ConnectResponse::set_use_bindless_rpc(bool value) {
+  set_has_use_bindless_rpc();
+  use_bindless_rpc_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.ConnectResponse.use_bindless_rpc)
+}
+
+// optional .bgs.protocol.connection.v1.ConnectionMeteringContentHandles binary_content_handle_array = 8;
+inline bool ConnectResponse::has_binary_content_handle_array() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void ConnectResponse::set_has_binary_content_handle_array() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void ConnectResponse::clear_has_binary_content_handle_array() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void ConnectResponse::clear_binary_content_handle_array() {
+  if (binary_content_handle_array_ != NULL) binary_content_handle_array_->::bgs::protocol::connection::v1::ConnectionMeteringContentHandles::Clear();
+  clear_has_binary_content_handle_array();
+}
+inline const ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles& ConnectResponse::binary_content_handle_array() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.ConnectResponse.binary_content_handle_array)
+  return binary_content_handle_array_ != NULL ? *binary_content_handle_array_ : *default_instance_->binary_content_handle_array_;
+}
+inline ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* ConnectResponse::mutable_binary_content_handle_array() {
+  set_has_binary_content_handle_array();
+  if (binary_content_handle_array_ == NULL) binary_content_handle_array_ = new ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.ConnectResponse.binary_content_handle_array)
+  return binary_content_handle_array_;
+}
+inline ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* ConnectResponse::release_binary_content_handle_array() {
+  clear_has_binary_content_handle_array();
+  ::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* temp = binary_content_handle_array_;
+  binary_content_handle_array_ = NULL;
+  return temp;
+}
+inline void ConnectResponse::set_allocated_binary_content_handle_array(::bgs::protocol::connection::v1::ConnectionMeteringContentHandles* binary_content_handle_array) {
+  delete binary_content_handle_array_;
+  binary_content_handle_array_ = binary_content_handle_array;
+  if (binary_content_handle_array) {
+    set_has_binary_content_handle_array();
+  } else {
+    clear_has_binary_content_handle_array();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.ConnectResponse.binary_content_handle_array)
+}
+
+// -------------------------------------------------------------------
+
+// BoundService
+
+// required fixed32 hash = 1;
+inline bool BoundService::has_hash() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void BoundService::set_has_hash() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void BoundService::clear_has_hash() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void BoundService::clear_hash() {
+  hash_ = 0u;
+  clear_has_hash();
+}
+inline ::google::protobuf::uint32 BoundService::hash() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.BoundService.hash)
+  return hash_;
+}
+inline void BoundService::set_hash(::google::protobuf::uint32 value) {
+  set_has_hash();
+  hash_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.BoundService.hash)
+}
+
+// required uint32 id = 2;
+inline bool BoundService::has_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void BoundService::set_has_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void BoundService::clear_has_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void BoundService::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 BoundService::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.BoundService.id)
+  return id_;
+}
+inline void BoundService::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.BoundService.id)
+}
+
+// -------------------------------------------------------------------
+
+// BindRequest
+
+// repeated fixed32 deprecated_imported_service_hash = 1 [packed = true, deprecated = true];
+inline int BindRequest::deprecated_imported_service_hash_size() const {
+  return deprecated_imported_service_hash_.size();
+}
+inline void BindRequest::clear_deprecated_imported_service_hash() {
+  deprecated_imported_service_hash_.Clear();
+}
+inline ::google::protobuf::uint32 BindRequest::deprecated_imported_service_hash(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.BindRequest.deprecated_imported_service_hash)
+  return deprecated_imported_service_hash_.Get(index);
+}
+inline void BindRequest::set_deprecated_imported_service_hash(int index, ::google::protobuf::uint32 value) {
+  deprecated_imported_service_hash_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.BindRequest.deprecated_imported_service_hash)
+}
+inline void BindRequest::add_deprecated_imported_service_hash(::google::protobuf::uint32 value) {
+  deprecated_imported_service_hash_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.connection.v1.BindRequest.deprecated_imported_service_hash)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+BindRequest::deprecated_imported_service_hash() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.connection.v1.BindRequest.deprecated_imported_service_hash)
+  return deprecated_imported_service_hash_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+BindRequest::mutable_deprecated_imported_service_hash() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.connection.v1.BindRequest.deprecated_imported_service_hash)
+  return &deprecated_imported_service_hash_;
+}
+
+// repeated .bgs.protocol.connection.v1.BoundService deprecated_exported_service = 2 [deprecated = true];
+inline int BindRequest::deprecated_exported_service_size() const {
+  return deprecated_exported_service_.size();
+}
+inline void BindRequest::clear_deprecated_exported_service() {
+  deprecated_exported_service_.Clear();
+}
+inline const ::bgs::protocol::connection::v1::BoundService& BindRequest::deprecated_exported_service(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.BindRequest.deprecated_exported_service)
+  return deprecated_exported_service_.Get(index);
+}
+inline ::bgs::protocol::connection::v1::BoundService* BindRequest::mutable_deprecated_exported_service(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.BindRequest.deprecated_exported_service)
+  return deprecated_exported_service_.Mutable(index);
+}
+inline ::bgs::protocol::connection::v1::BoundService* BindRequest::add_deprecated_exported_service() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.connection.v1.BindRequest.deprecated_exported_service)
+  return deprecated_exported_service_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >&
+BindRequest::deprecated_exported_service() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.connection.v1.BindRequest.deprecated_exported_service)
+  return deprecated_exported_service_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >*
+BindRequest::mutable_deprecated_exported_service() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.connection.v1.BindRequest.deprecated_exported_service)
+  return &deprecated_exported_service_;
+}
+
+// repeated .bgs.protocol.connection.v1.BoundService exported_service = 3;
+inline int BindRequest::exported_service_size() const {
+  return exported_service_.size();
+}
+inline void BindRequest::clear_exported_service() {
+  exported_service_.Clear();
+}
+inline const ::bgs::protocol::connection::v1::BoundService& BindRequest::exported_service(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.BindRequest.exported_service)
+  return exported_service_.Get(index);
+}
+inline ::bgs::protocol::connection::v1::BoundService* BindRequest::mutable_exported_service(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.BindRequest.exported_service)
+  return exported_service_.Mutable(index);
+}
+inline ::bgs::protocol::connection::v1::BoundService* BindRequest::add_exported_service() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.connection.v1.BindRequest.exported_service)
+  return exported_service_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >&
+BindRequest::exported_service() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.connection.v1.BindRequest.exported_service)
+  return exported_service_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >*
+BindRequest::mutable_exported_service() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.connection.v1.BindRequest.exported_service)
+  return &exported_service_;
+}
+
+// repeated .bgs.protocol.connection.v1.BoundService imported_service = 4;
+inline int BindRequest::imported_service_size() const {
+  return imported_service_.size();
+}
+inline void BindRequest::clear_imported_service() {
+  imported_service_.Clear();
+}
+inline const ::bgs::protocol::connection::v1::BoundService& BindRequest::imported_service(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.BindRequest.imported_service)
+  return imported_service_.Get(index);
+}
+inline ::bgs::protocol::connection::v1::BoundService* BindRequest::mutable_imported_service(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.BindRequest.imported_service)
+  return imported_service_.Mutable(index);
+}
+inline ::bgs::protocol::connection::v1::BoundService* BindRequest::add_imported_service() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.connection.v1.BindRequest.imported_service)
+  return imported_service_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >&
+BindRequest::imported_service() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.connection.v1.BindRequest.imported_service)
+  return imported_service_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::connection::v1::BoundService >*
+BindRequest::mutable_imported_service() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.connection.v1.BindRequest.imported_service)
+  return &imported_service_;
+}
+
+// -------------------------------------------------------------------
+
+// BindResponse
+
+// repeated uint32 imported_service_id = 1 [packed = true, deprecated = true];
+inline int BindResponse::imported_service_id_size() const {
+  return imported_service_id_.size();
+}
+inline void BindResponse::clear_imported_service_id() {
+  imported_service_id_.Clear();
+}
+inline ::google::protobuf::uint32 BindResponse::imported_service_id(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.BindResponse.imported_service_id)
+  return imported_service_id_.Get(index);
+}
+inline void BindResponse::set_imported_service_id(int index, ::google::protobuf::uint32 value) {
+  imported_service_id_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.BindResponse.imported_service_id)
+}
+inline void BindResponse::add_imported_service_id(::google::protobuf::uint32 value) {
+  imported_service_id_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.connection.v1.BindResponse.imported_service_id)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+BindResponse::imported_service_id() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.connection.v1.BindResponse.imported_service_id)
+  return imported_service_id_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+BindResponse::mutable_imported_service_id() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.connection.v1.BindResponse.imported_service_id)
+  return &imported_service_id_;
+}
+
+// -------------------------------------------------------------------
+
+// EchoRequest
+
+// optional fixed64 time = 1;
+inline bool EchoRequest::has_time() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void EchoRequest::set_has_time() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void EchoRequest::clear_has_time() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void EchoRequest::clear_time() {
+  time_ = GOOGLE_ULONGLONG(0);
+  clear_has_time();
+}
+inline ::google::protobuf::uint64 EchoRequest::time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.EchoRequest.time)
+  return time_;
+}
+inline void EchoRequest::set_time(::google::protobuf::uint64 value) {
+  set_has_time();
+  time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.EchoRequest.time)
+}
+
+// optional bool network_only = 2 [default = false];
+inline bool EchoRequest::has_network_only() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void EchoRequest::set_has_network_only() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void EchoRequest::clear_has_network_only() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void EchoRequest::clear_network_only() {
+  network_only_ = false;
+  clear_has_network_only();
+}
+inline bool EchoRequest::network_only() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.EchoRequest.network_only)
+  return network_only_;
+}
+inline void EchoRequest::set_network_only(bool value) {
+  set_has_network_only();
+  network_only_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.EchoRequest.network_only)
+}
+
+// optional bytes payload = 3;
+inline bool EchoRequest::has_payload() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void EchoRequest::set_has_payload() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void EchoRequest::clear_has_payload() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void EchoRequest::clear_payload() {
+  if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_->clear();
+  }
+  clear_has_payload();
+}
+inline const ::std::string& EchoRequest::payload() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.EchoRequest.payload)
+  return *payload_;
+}
+inline void EchoRequest::set_payload(const ::std::string& value) {
+  set_has_payload();
+  if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_ = new ::std::string;
+  }
+  payload_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.EchoRequest.payload)
+}
+inline void EchoRequest::set_payload(const char* value) {
+  set_has_payload();
+  if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_ = new ::std::string;
+  }
+  payload_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.connection.v1.EchoRequest.payload)
+}
+inline void EchoRequest::set_payload(const void* value, size_t size) {
+  set_has_payload();
+  if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_ = new ::std::string;
+  }
+  payload_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.connection.v1.EchoRequest.payload)
+}
+inline ::std::string* EchoRequest::mutable_payload() {
+  set_has_payload();
+  if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.EchoRequest.payload)
+  return payload_;
+}
+inline ::std::string* EchoRequest::release_payload() {
+  clear_has_payload();
+  if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = payload_;
+    payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void EchoRequest::set_allocated_payload(::std::string* payload) {
+  if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete payload_;
+  }
+  if (payload) {
+    set_has_payload();
+    payload_ = payload;
+  } else {
+    clear_has_payload();
+    payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.EchoRequest.payload)
+}
+
+// -------------------------------------------------------------------
+
+// EchoResponse
+
+// optional fixed64 time = 1;
+inline bool EchoResponse::has_time() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void EchoResponse::set_has_time() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void EchoResponse::clear_has_time() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void EchoResponse::clear_time() {
+  time_ = GOOGLE_ULONGLONG(0);
+  clear_has_time();
+}
+inline ::google::protobuf::uint64 EchoResponse::time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.EchoResponse.time)
+  return time_;
+}
+inline void EchoResponse::set_time(::google::protobuf::uint64 value) {
+  set_has_time();
+  time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.EchoResponse.time)
+}
+
+// optional bytes payload = 2;
+inline bool EchoResponse::has_payload() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void EchoResponse::set_has_payload() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void EchoResponse::clear_has_payload() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void EchoResponse::clear_payload() {
+  if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_->clear();
+  }
+  clear_has_payload();
+}
+inline const ::std::string& EchoResponse::payload() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.EchoResponse.payload)
+  return *payload_;
+}
+inline void EchoResponse::set_payload(const ::std::string& value) {
+  set_has_payload();
+  if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_ = new ::std::string;
+  }
+  payload_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.EchoResponse.payload)
+}
+inline void EchoResponse::set_payload(const char* value) {
+  set_has_payload();
+  if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_ = new ::std::string;
+  }
+  payload_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.connection.v1.EchoResponse.payload)
+}
+inline void EchoResponse::set_payload(const void* value, size_t size) {
+  set_has_payload();
+  if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_ = new ::std::string;
+  }
+  payload_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.connection.v1.EchoResponse.payload)
+}
+inline ::std::string* EchoResponse::mutable_payload() {
+  set_has_payload();
+  if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    payload_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.EchoResponse.payload)
+  return payload_;
+}
+inline ::std::string* EchoResponse::release_payload() {
+  clear_has_payload();
+  if (payload_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = payload_;
+    payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void EchoResponse::set_allocated_payload(::std::string* payload) {
+  if (payload_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete payload_;
+  }
+  if (payload) {
+    set_has_payload();
+    payload_ = payload;
+  } else {
+    clear_has_payload();
+    payload_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.EchoResponse.payload)
+}
+
+// -------------------------------------------------------------------
+
+// DisconnectRequest
+
+// required uint32 error_code = 1;
+inline bool DisconnectRequest::has_error_code() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void DisconnectRequest::set_has_error_code() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void DisconnectRequest::clear_has_error_code() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void DisconnectRequest::clear_error_code() {
+  error_code_ = 0u;
+  clear_has_error_code();
+}
+inline ::google::protobuf::uint32 DisconnectRequest::error_code() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.DisconnectRequest.error_code)
+  return error_code_;
+}
+inline void DisconnectRequest::set_error_code(::google::protobuf::uint32 value) {
+  set_has_error_code();
+  error_code_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.DisconnectRequest.error_code)
+}
+
+// -------------------------------------------------------------------
+
+// DisconnectNotification
+
+// required uint32 error_code = 1;
+inline bool DisconnectNotification::has_error_code() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void DisconnectNotification::set_has_error_code() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void DisconnectNotification::clear_has_error_code() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void DisconnectNotification::clear_error_code() {
+  error_code_ = 0u;
+  clear_has_error_code();
+}
+inline ::google::protobuf::uint32 DisconnectNotification::error_code() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.DisconnectNotification.error_code)
+  return error_code_;
+}
+inline void DisconnectNotification::set_error_code(::google::protobuf::uint32 value) {
+  set_has_error_code();
+  error_code_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.DisconnectNotification.error_code)
+}
+
+// optional string reason = 2;
+inline bool DisconnectNotification::has_reason() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void DisconnectNotification::set_has_reason() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void DisconnectNotification::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void DisconnectNotification::clear_reason() {
+  if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_->clear();
+  }
+  clear_has_reason();
+}
+inline const ::std::string& DisconnectNotification::reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.connection.v1.DisconnectNotification.reason)
+  return *reason_;
+}
+inline void DisconnectNotification::set_reason(const ::std::string& value) {
+  set_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_ = new ::std::string;
+  }
+  reason_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.connection.v1.DisconnectNotification.reason)
+}
+inline void DisconnectNotification::set_reason(const char* value) {
+  set_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_ = new ::std::string;
+  }
+  reason_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.connection.v1.DisconnectNotification.reason)
+}
+inline void DisconnectNotification::set_reason(const char* value, size_t size) {
+  set_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_ = new ::std::string;
+  }
+  reason_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.connection.v1.DisconnectNotification.reason)
+}
+inline ::std::string* DisconnectNotification::mutable_reason() {
+  set_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    reason_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.connection.v1.DisconnectNotification.reason)
+  return reason_;
+}
+inline ::std::string* DisconnectNotification::release_reason() {
+  clear_has_reason();
+  if (reason_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = reason_;
+    reason_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void DisconnectNotification::set_allocated_reason(::std::string* reason) {
+  if (reason_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete reason_;
+  }
+  if (reason) {
+    set_has_reason();
+    reason_ = reason;
+  } else {
+    clear_has_reason();
+    reason_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.connection.v1.DisconnectNotification.reason)
+}
+
+// -------------------------------------------------------------------
+
+// EncryptRequest
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace connection
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_connection_5fservice_2eproto__INCLUDED
diff --git a/src/server/proto/Client/content_handle_types.pb.cc b/src/server/proto/Client/content_handle_types.pb.cc
new file mode 100644
index 00000000000..6f480167d10
--- /dev/null
+++ b/src/server/proto/Client/content_handle_types.pb.cc
@@ -0,0 +1,496 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: content_handle_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "content_handle_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+
+namespace {
+
+const ::google::protobuf::Descriptor* ContentHandle_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ContentHandle_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_content_5fhandle_5ftypes_2eproto() {
+  protobuf_AddDesc_content_5fhandle_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "content_handle_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  ContentHandle_descriptor_ = file->message_type(0);
+  static const int ContentHandle_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandle, region_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandle, usage_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandle, hash_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandle, proto_url_),
+  };
+  ContentHandle_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ContentHandle_descriptor_,
+      ContentHandle::default_instance_,
+      ContentHandle_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandle, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandle, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ContentHandle));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_content_5fhandle_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ContentHandle_descriptor_, &ContentHandle::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_content_5fhandle_5ftypes_2eproto() {
+  delete ContentHandle::default_instance_;
+  delete ContentHandle_reflection_;
+}
+
+void protobuf_AddDesc_content_5fhandle_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\032content_handle_types.proto\022\014bgs.protoc"
+    "ol\"O\n\rContentHandle\022\016\n\006region\030\001 \002(\007\022\r\n\005u"
+    "sage\030\002 \002(\007\022\014\n\004hash\030\003 \002(\014\022\021\n\tproto_url\030\004 "
+    "\001(\tB%\n\rbnet.protocolB\022ContentHandleProto"
+    "H\001", 162);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "content_handle_types.proto", &protobuf_RegisterTypes);
+  ContentHandle::default_instance_ = new ContentHandle();
+  ContentHandle::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_content_5fhandle_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_content_5fhandle_5ftypes_2eproto {
+  StaticDescriptorInitializer_content_5fhandle_5ftypes_2eproto() {
+    protobuf_AddDesc_content_5fhandle_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_content_5fhandle_5ftypes_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ContentHandle::kRegionFieldNumber;
+const int ContentHandle::kUsageFieldNumber;
+const int ContentHandle::kHashFieldNumber;
+const int ContentHandle::kProtoUrlFieldNumber;
+#endif  // !_MSC_VER
+
+ContentHandle::ContentHandle()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.ContentHandle)
+}
+
+void ContentHandle::InitAsDefaultInstance() {
+}
+
+ContentHandle::ContentHandle(const ContentHandle& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.ContentHandle)
+}
+
+void ContentHandle::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  region_ = 0u;
+  usage_ = 0u;
+  hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  proto_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ContentHandle::~ContentHandle() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.ContentHandle)
+  SharedDtor();
+}
+
+void ContentHandle::SharedDtor() {
+  if (hash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete hash_;
+  }
+  if (proto_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete proto_url_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ContentHandle::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ContentHandle::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ContentHandle_descriptor_;
+}
+
+const ContentHandle& ContentHandle::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_content_5fhandle_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ContentHandle* ContentHandle::default_instance_ = NULL;
+
+ContentHandle* ContentHandle::New() const {
+  return new ContentHandle;
+}
+
+void ContentHandle::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ContentHandle*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(region_, usage_);
+    if (has_hash()) {
+      if (hash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        hash_->clear();
+      }
+    }
+    if (has_proto_url()) {
+      if (proto_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        proto_url_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ContentHandle::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.ContentHandle)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required fixed32 region = 1;
+      case 1: {
+        if (tag == 13) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &region_)));
+          set_has_region();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(21)) goto parse_usage;
+        break;
+      }
+
+      // required fixed32 usage = 2;
+      case 2: {
+        if (tag == 21) {
+         parse_usage:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &usage_)));
+          set_has_usage();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_hash;
+        break;
+      }
+
+      // required bytes hash = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_hash:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_hash()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_proto_url;
+        break;
+      }
+
+      // optional string proto_url = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_proto_url:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_proto_url()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->proto_url().data(), this->proto_url().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "proto_url");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.ContentHandle)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.ContentHandle)
+  return false;
+#undef DO_
+}
+
+void ContentHandle::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.ContentHandle)
+  // required fixed32 region = 1;
+  if (has_region()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->region(), output);
+  }
+
+  // required fixed32 usage = 2;
+  if (has_usage()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->usage(), output);
+  }
+
+  // required bytes hash = 3;
+  if (has_hash()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      3, this->hash(), output);
+  }
+
+  // optional string proto_url = 4;
+  if (has_proto_url()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->proto_url().data(), this->proto_url().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "proto_url");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->proto_url(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.ContentHandle)
+}
+
+::google::protobuf::uint8* ContentHandle::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.ContentHandle)
+  // required fixed32 region = 1;
+  if (has_region()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->region(), target);
+  }
+
+  // required fixed32 usage = 2;
+  if (has_usage()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->usage(), target);
+  }
+
+  // required bytes hash = 3;
+  if (has_hash()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        3, this->hash(), target);
+  }
+
+  // optional string proto_url = 4;
+  if (has_proto_url()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->proto_url().data(), this->proto_url().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "proto_url");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->proto_url(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.ContentHandle)
+  return target;
+}
+
+int ContentHandle::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required fixed32 region = 1;
+    if (has_region()) {
+      total_size += 1 + 4;
+    }
+
+    // required fixed32 usage = 2;
+    if (has_usage()) {
+      total_size += 1 + 4;
+    }
+
+    // required bytes hash = 3;
+    if (has_hash()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->hash());
+    }
+
+    // optional string proto_url = 4;
+    if (has_proto_url()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->proto_url());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ContentHandle::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ContentHandle* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ContentHandle*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ContentHandle::MergeFrom(const ContentHandle& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_region()) {
+      set_region(from.region());
+    }
+    if (from.has_usage()) {
+      set_usage(from.usage());
+    }
+    if (from.has_hash()) {
+      set_hash(from.hash());
+    }
+    if (from.has_proto_url()) {
+      set_proto_url(from.proto_url());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ContentHandle::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ContentHandle::CopyFrom(const ContentHandle& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ContentHandle::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
+
+  return true;
+}
+
+void ContentHandle::Swap(ContentHandle* other) {
+  if (other != this) {
+    std::swap(region_, other->region_);
+    std::swap(usage_, other->usage_);
+    std::swap(hash_, other->hash_);
+    std::swap(proto_url_, other->proto_url_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ContentHandle::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ContentHandle_descriptor_;
+  metadata.reflection = ContentHandle_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/content_handle_types.pb.h b/src/server/proto/Client/content_handle_types.pb.h
new file mode 100644
index 00000000000..d2f69e1329f
--- /dev/null
+++ b/src/server/proto/Client/content_handle_types.pb.h
@@ -0,0 +1,386 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: content_handle_types.proto
+
+#ifndef PROTOBUF_content_5fhandle_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_content_5fhandle_5ftypes_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 "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_content_5fhandle_5ftypes_2eproto();
+void protobuf_AssignDesc_content_5fhandle_5ftypes_2eproto();
+void protobuf_ShutdownFile_content_5fhandle_5ftypes_2eproto();
+
+class ContentHandle;
+
+// ===================================================================
+
+class TC_SHARED_API ContentHandle : public ::google::protobuf::Message {
+ public:
+  ContentHandle();
+  virtual ~ContentHandle();
+
+  ContentHandle(const ContentHandle& from);
+
+  inline ContentHandle& operator=(const ContentHandle& 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 ContentHandle& default_instance();
+
+  void Swap(ContentHandle* other);
+
+  // implements Message ----------------------------------------------
+
+  ContentHandle* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ContentHandle& from);
+  void MergeFrom(const ContentHandle& 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 fixed32 region = 1;
+  inline bool has_region() const;
+  inline void clear_region();
+  static const int kRegionFieldNumber = 1;
+  inline ::google::protobuf::uint32 region() const;
+  inline void set_region(::google::protobuf::uint32 value);
+
+  // required fixed32 usage = 2;
+  inline bool has_usage() const;
+  inline void clear_usage();
+  static const int kUsageFieldNumber = 2;
+  inline ::google::protobuf::uint32 usage() const;
+  inline void set_usage(::google::protobuf::uint32 value);
+
+  // required bytes hash = 3;
+  inline bool has_hash() const;
+  inline void clear_hash();
+  static const int kHashFieldNumber = 3;
+  inline const ::std::string& hash() const;
+  inline void set_hash(const ::std::string& value);
+  inline void set_hash(const char* value);
+  inline void set_hash(const void* value, size_t size);
+  inline ::std::string* mutable_hash();
+  inline ::std::string* release_hash();
+  inline void set_allocated_hash(::std::string* hash);
+
+  // optional string proto_url = 4;
+  inline bool has_proto_url() const;
+  inline void clear_proto_url();
+  static const int kProtoUrlFieldNumber = 4;
+  inline const ::std::string& proto_url() const;
+  inline void set_proto_url(const ::std::string& value);
+  inline void set_proto_url(const char* value);
+  inline void set_proto_url(const char* value, size_t size);
+  inline ::std::string* mutable_proto_url();
+  inline ::std::string* release_proto_url();
+  inline void set_allocated_proto_url(::std::string* proto_url);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.ContentHandle)
+ private:
+  inline void set_has_region();
+  inline void clear_has_region();
+  inline void set_has_usage();
+  inline void clear_has_usage();
+  inline void set_has_hash();
+  inline void clear_has_hash();
+  inline void set_has_proto_url();
+  inline void clear_has_proto_url();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 region_;
+  ::google::protobuf::uint32 usage_;
+  ::std::string* hash_;
+  ::std::string* proto_url_;
+  friend void TC_SHARED_API protobuf_AddDesc_content_5fhandle_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_content_5fhandle_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_content_5fhandle_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ContentHandle* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// ContentHandle
+
+// required fixed32 region = 1;
+inline bool ContentHandle::has_region() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ContentHandle::set_has_region() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ContentHandle::clear_has_region() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ContentHandle::clear_region() {
+  region_ = 0u;
+  clear_has_region();
+}
+inline ::google::protobuf::uint32 ContentHandle::region() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.ContentHandle.region)
+  return region_;
+}
+inline void ContentHandle::set_region(::google::protobuf::uint32 value) {
+  set_has_region();
+  region_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.ContentHandle.region)
+}
+
+// required fixed32 usage = 2;
+inline bool ContentHandle::has_usage() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ContentHandle::set_has_usage() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ContentHandle::clear_has_usage() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ContentHandle::clear_usage() {
+  usage_ = 0u;
+  clear_has_usage();
+}
+inline ::google::protobuf::uint32 ContentHandle::usage() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.ContentHandle.usage)
+  return usage_;
+}
+inline void ContentHandle::set_usage(::google::protobuf::uint32 value) {
+  set_has_usage();
+  usage_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.ContentHandle.usage)
+}
+
+// required bytes hash = 3;
+inline bool ContentHandle::has_hash() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ContentHandle::set_has_hash() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ContentHandle::clear_has_hash() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ContentHandle::clear_hash() {
+  if (hash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    hash_->clear();
+  }
+  clear_has_hash();
+}
+inline const ::std::string& ContentHandle::hash() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.ContentHandle.hash)
+  return *hash_;
+}
+inline void ContentHandle::set_hash(const ::std::string& value) {
+  set_has_hash();
+  if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    hash_ = new ::std::string;
+  }
+  hash_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.ContentHandle.hash)
+}
+inline void ContentHandle::set_hash(const char* value) {
+  set_has_hash();
+  if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    hash_ = new ::std::string;
+  }
+  hash_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.ContentHandle.hash)
+}
+inline void ContentHandle::set_hash(const void* value, size_t size) {
+  set_has_hash();
+  if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    hash_ = new ::std::string;
+  }
+  hash_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.ContentHandle.hash)
+}
+inline ::std::string* ContentHandle::mutable_hash() {
+  set_has_hash();
+  if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    hash_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.ContentHandle.hash)
+  return hash_;
+}
+inline ::std::string* ContentHandle::release_hash() {
+  clear_has_hash();
+  if (hash_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = hash_;
+    hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ContentHandle::set_allocated_hash(::std::string* hash) {
+  if (hash_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete hash_;
+  }
+  if (hash) {
+    set_has_hash();
+    hash_ = hash;
+  } else {
+    clear_has_hash();
+    hash_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.ContentHandle.hash)
+}
+
+// optional string proto_url = 4;
+inline bool ContentHandle::has_proto_url() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ContentHandle::set_has_proto_url() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ContentHandle::clear_has_proto_url() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ContentHandle::clear_proto_url() {
+  if (proto_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    proto_url_->clear();
+  }
+  clear_has_proto_url();
+}
+inline const ::std::string& ContentHandle::proto_url() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.ContentHandle.proto_url)
+  return *proto_url_;
+}
+inline void ContentHandle::set_proto_url(const ::std::string& value) {
+  set_has_proto_url();
+  if (proto_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    proto_url_ = new ::std::string;
+  }
+  proto_url_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.ContentHandle.proto_url)
+}
+inline void ContentHandle::set_proto_url(const char* value) {
+  set_has_proto_url();
+  if (proto_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    proto_url_ = new ::std::string;
+  }
+  proto_url_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.ContentHandle.proto_url)
+}
+inline void ContentHandle::set_proto_url(const char* value, size_t size) {
+  set_has_proto_url();
+  if (proto_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    proto_url_ = new ::std::string;
+  }
+  proto_url_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.ContentHandle.proto_url)
+}
+inline ::std::string* ContentHandle::mutable_proto_url() {
+  set_has_proto_url();
+  if (proto_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    proto_url_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.ContentHandle.proto_url)
+  return proto_url_;
+}
+inline ::std::string* ContentHandle::release_proto_url() {
+  clear_has_proto_url();
+  if (proto_url_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = proto_url_;
+    proto_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ContentHandle::set_allocated_proto_url(::std::string* proto_url) {
+  if (proto_url_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete proto_url_;
+  }
+  if (proto_url) {
+    set_has_proto_url();
+    proto_url_ = proto_url;
+  } else {
+    clear_has_proto_url();
+    proto_url_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.ContentHandle.proto_url)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_content_5fhandle_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/entity_types.pb.cc b/src/server/proto/Client/entity_types.pb.cc
new file mode 100644
index 00000000000..29e95bdf0e9
--- /dev/null
+++ b/src/server/proto/Client/entity_types.pb.cc
@@ -0,0 +1,1177 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: entity_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "entity_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+
+namespace {
+
+const ::google::protobuf::Descriptor* EntityId_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  EntityId_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Identity_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Identity_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AccountInfo_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AccountInfo_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_entity_5ftypes_2eproto() {
+  protobuf_AddDesc_entity_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "entity_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  EntityId_descriptor_ = file->message_type(0);
+  static const int EntityId_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EntityId, high_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EntityId, low_),
+  };
+  EntityId_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      EntityId_descriptor_,
+      EntityId::default_instance_,
+      EntityId_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EntityId, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EntityId, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(EntityId));
+  Identity_descriptor_ = file->message_type(1);
+  static const int Identity_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, game_account_id_),
+  };
+  Identity_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Identity_descriptor_,
+      Identity::default_instance_,
+      Identity_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Identity, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Identity));
+  AccountInfo_descriptor_ = file->message_type(2);
+  static const int AccountInfo_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, account_paid_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, country_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, battle_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, manual_review_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, identity_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, account_muted_),
+  };
+  AccountInfo_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AccountInfo_descriptor_,
+      AccountInfo::default_instance_,
+      AccountInfo_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AccountInfo, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AccountInfo));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_entity_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    EntityId_descriptor_, &EntityId::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Identity_descriptor_, &Identity::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AccountInfo_descriptor_, &AccountInfo::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_entity_5ftypes_2eproto() {
+  delete EntityId::default_instance_;
+  delete EntityId_reflection_;
+  delete Identity::default_instance_;
+  delete Identity_reflection_;
+  delete AccountInfo::default_instance_;
+  delete AccountInfo_reflection_;
+}
+
+void protobuf_AddDesc_entity_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\022entity_types.proto\022\014bgs.protocol\032%glob"
+    "al_extensions/field_options.proto\"1\n\010Ent"
+    "ityId\022\022\n\004high\030\001 \002(\006B\004\200\265\030\002\022\021\n\003low\030\002 \002(\006B\004"
+    "\200\265\030\002\"g\n\010Identity\022*\n\naccount_id\030\001 \001(\0132\026.b"
+    "gs.protocol.EntityId\022/\n\017game_account_id\030"
+    "\002 \001(\0132\026.bgs.protocol.EntityId\"\273\001\n\013Accoun"
+    "tInfo\022\033\n\014account_paid\030\001 \001(\010:\005false\022\025\n\nco"
+    "untry_id\030\002 \001(\007:\0010\022\022\n\nbattle_tag\030\003 \001(\t\022\034\n"
+    "\rmanual_review\030\004 \001(\010:\005false\022(\n\010identity\030"
+    "\005 \001(\0132\026.bgs.protocol.Identity\022\034\n\raccount"
+    "_muted\030\006 \001(\010:\005falseB\036\n\rbnet.protocolB\013En"
+    "tityProtoH\001", 451);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "entity_types.proto", &protobuf_RegisterTypes);
+  EntityId::default_instance_ = new EntityId();
+  Identity::default_instance_ = new Identity();
+  AccountInfo::default_instance_ = new AccountInfo();
+  EntityId::default_instance_->InitAsDefaultInstance();
+  Identity::default_instance_->InitAsDefaultInstance();
+  AccountInfo::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_entity_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_entity_5ftypes_2eproto {
+  StaticDescriptorInitializer_entity_5ftypes_2eproto() {
+    protobuf_AddDesc_entity_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_entity_5ftypes_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int EntityId::kHighFieldNumber;
+const int EntityId::kLowFieldNumber;
+#endif  // !_MSC_VER
+
+EntityId::EntityId()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.EntityId)
+}
+
+void EntityId::InitAsDefaultInstance() {
+}
+
+EntityId::EntityId(const EntityId& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.EntityId)
+}
+
+void EntityId::SharedCtor() {
+  _cached_size_ = 0;
+  high_ = GOOGLE_ULONGLONG(0);
+  low_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+EntityId::~EntityId() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.EntityId)
+  SharedDtor();
+}
+
+void EntityId::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void EntityId::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* EntityId::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return EntityId_descriptor_;
+}
+
+const EntityId& EntityId::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_entity_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+EntityId* EntityId::default_instance_ = NULL;
+
+EntityId* EntityId::New() const {
+  return new EntityId;
+}
+
+void EntityId::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<EntityId*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(high_, low_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool EntityId::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.EntityId)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required fixed64 high = 1;
+      case 1: {
+        if (tag == 9) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &high_)));
+          set_has_high();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(17)) goto parse_low;
+        break;
+      }
+
+      // required fixed64 low = 2;
+      case 2: {
+        if (tag == 17) {
+         parse_low:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &low_)));
+          set_has_low();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.EntityId)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.EntityId)
+  return false;
+#undef DO_
+}
+
+void EntityId::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.EntityId)
+  // required fixed64 high = 1;
+  if (has_high()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->high(), output);
+  }
+
+  // required fixed64 low = 2;
+  if (has_low()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->low(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.EntityId)
+}
+
+::google::protobuf::uint8* EntityId::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.EntityId)
+  // required fixed64 high = 1;
+  if (has_high()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->high(), target);
+  }
+
+  // required fixed64 low = 2;
+  if (has_low()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->low(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.EntityId)
+  return target;
+}
+
+int EntityId::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required fixed64 high = 1;
+    if (has_high()) {
+      total_size += 1 + 8;
+    }
+
+    // required fixed64 low = 2;
+    if (has_low()) {
+      total_size += 1 + 8;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void EntityId::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const EntityId* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const EntityId*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void EntityId::MergeFrom(const EntityId& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_high()) {
+      set_high(from.high());
+    }
+    if (from.has_low()) {
+      set_low(from.low());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void EntityId::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void EntityId::CopyFrom(const EntityId& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool EntityId::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  return true;
+}
+
+void EntityId::Swap(EntityId* other) {
+  if (other != this) {
+    std::swap(high_, other->high_);
+    std::swap(low_, other->low_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata EntityId::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = EntityId_descriptor_;
+  metadata.reflection = EntityId_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Identity::kAccountIdFieldNumber;
+const int Identity::kGameAccountIdFieldNumber;
+#endif  // !_MSC_VER
+
+Identity::Identity()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.Identity)
+}
+
+void Identity::InitAsDefaultInstance() {
+  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+Identity::Identity(const Identity& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.Identity)
+}
+
+void Identity::SharedCtor() {
+  _cached_size_ = 0;
+  account_id_ = NULL;
+  game_account_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Identity::~Identity() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.Identity)
+  SharedDtor();
+}
+
+void Identity::SharedDtor() {
+  if (this != default_instance_) {
+    delete account_id_;
+    delete game_account_id_;
+  }
+}
+
+void Identity::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Identity::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Identity_descriptor_;
+}
+
+const Identity& Identity::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_entity_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Identity* Identity::default_instance_ = NULL;
+
+Identity* Identity::New() const {
+  return new Identity;
+}
+
+void Identity::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_game_account_id()) {
+      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Identity::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.Identity)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId account_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_game_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId game_account_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_game_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.Identity)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.Identity)
+  return false;
+#undef DO_
+}
+
+void Identity::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.Identity)
+  // optional .bgs.protocol.EntityId account_id = 1;
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->account_id(), output);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->game_account_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.Identity)
+}
+
+::google::protobuf::uint8* Identity::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Identity)
+  // optional .bgs.protocol.EntityId account_id = 1;
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->account_id(), target);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->game_account_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Identity)
+  return target;
+}
+
+int Identity::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId account_id = 1;
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+    // optional .bgs.protocol.EntityId game_account_id = 2;
+    if (has_game_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Identity::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Identity* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Identity*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Identity::MergeFrom(const Identity& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
+    }
+    if (from.has_game_account_id()) {
+      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Identity::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Identity::CopyFrom(const Identity& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Identity::IsInitialized() const {
+
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  if (has_game_account_id()) {
+    if (!this->game_account_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void Identity::Swap(Identity* other) {
+  if (other != this) {
+    std::swap(account_id_, other->account_id_);
+    std::swap(game_account_id_, other->game_account_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Identity::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Identity_descriptor_;
+  metadata.reflection = Identity_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AccountInfo::kAccountPaidFieldNumber;
+const int AccountInfo::kCountryIdFieldNumber;
+const int AccountInfo::kBattleTagFieldNumber;
+const int AccountInfo::kManualReviewFieldNumber;
+const int AccountInfo::kIdentityFieldNumber;
+const int AccountInfo::kAccountMutedFieldNumber;
+#endif  // !_MSC_VER
+
+AccountInfo::AccountInfo()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.AccountInfo)
+}
+
+void AccountInfo::InitAsDefaultInstance() {
+  identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance());
+}
+
+AccountInfo::AccountInfo(const AccountInfo& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.AccountInfo)
+}
+
+void AccountInfo::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  account_paid_ = false;
+  country_id_ = 0u;
+  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  manual_review_ = false;
+  identity_ = NULL;
+  account_muted_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AccountInfo::~AccountInfo() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.AccountInfo)
+  SharedDtor();
+}
+
+void AccountInfo::SharedDtor() {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete battle_tag_;
+  }
+  if (this != default_instance_) {
+    delete identity_;
+  }
+}
+
+void AccountInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AccountInfo::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AccountInfo_descriptor_;
+}
+
+const AccountInfo& AccountInfo::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_entity_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+AccountInfo* AccountInfo::default_instance_ = NULL;
+
+AccountInfo* AccountInfo::New() const {
+  return new AccountInfo;
+}
+
+void AccountInfo::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<AccountInfo*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 63) {
+    ZR_(country_id_, account_muted_);
+    if (has_battle_tag()) {
+      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        battle_tag_->clear();
+      }
+    }
+    if (has_identity()) {
+      if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AccountInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.AccountInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bool account_paid = 1 [default = false];
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &account_paid_)));
+          set_has_account_paid();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(21)) goto parse_country_id;
+        break;
+      }
+
+      // optional fixed32 country_id = 2 [default = 0];
+      case 2: {
+        if (tag == 21) {
+         parse_country_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &country_id_)));
+          set_has_country_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_battle_tag;
+        break;
+      }
+
+      // optional string battle_tag = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_battle_tag:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_battle_tag()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->battle_tag().data(), this->battle_tag().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "battle_tag");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_manual_review;
+        break;
+      }
+
+      // optional bool manual_review = 4 [default = false];
+      case 4: {
+        if (tag == 32) {
+         parse_manual_review:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &manual_review_)));
+          set_has_manual_review();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_identity;
+        break;
+      }
+
+      // optional .bgs.protocol.Identity identity = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_identity:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_identity()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_account_muted;
+        break;
+      }
+
+      // optional bool account_muted = 6 [default = false];
+      case 6: {
+        if (tag == 48) {
+         parse_account_muted:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &account_muted_)));
+          set_has_account_muted();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.AccountInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.AccountInfo)
+  return false;
+#undef DO_
+}
+
+void AccountInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.AccountInfo)
+  // optional bool account_paid = 1 [default = false];
+  if (has_account_paid()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->account_paid(), output);
+  }
+
+  // optional fixed32 country_id = 2 [default = 0];
+  if (has_country_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->country_id(), output);
+  }
+
+  // optional string battle_tag = 3;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->battle_tag(), output);
+  }
+
+  // optional bool manual_review = 4 [default = false];
+  if (has_manual_review()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(4, this->manual_review(), output);
+  }
+
+  // optional .bgs.protocol.Identity identity = 5;
+  if (has_identity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->identity(), output);
+  }
+
+  // optional bool account_muted = 6 [default = false];
+  if (has_account_muted()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->account_muted(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.AccountInfo)
+}
+
+::google::protobuf::uint8* AccountInfo::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.AccountInfo)
+  // optional bool account_paid = 1 [default = false];
+  if (has_account_paid()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->account_paid(), target);
+  }
+
+  // optional fixed32 country_id = 2 [default = 0];
+  if (has_country_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->country_id(), target);
+  }
+
+  // optional string battle_tag = 3;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->battle_tag(), target);
+  }
+
+  // optional bool manual_review = 4 [default = false];
+  if (has_manual_review()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(4, this->manual_review(), target);
+  }
+
+  // optional .bgs.protocol.Identity identity = 5;
+  if (has_identity()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->identity(), target);
+  }
+
+  // optional bool account_muted = 6 [default = false];
+  if (has_account_muted()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->account_muted(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.AccountInfo)
+  return target;
+}
+
+int AccountInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bool account_paid = 1 [default = false];
+    if (has_account_paid()) {
+      total_size += 1 + 1;
+    }
+
+    // optional fixed32 country_id = 2 [default = 0];
+    if (has_country_id()) {
+      total_size += 1 + 4;
+    }
+
+    // optional string battle_tag = 3;
+    if (has_battle_tag()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->battle_tag());
+    }
+
+    // optional bool manual_review = 4 [default = false];
+    if (has_manual_review()) {
+      total_size += 1 + 1;
+    }
+
+    // optional .bgs.protocol.Identity identity = 5;
+    if (has_identity()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->identity());
+    }
+
+    // optional bool account_muted = 6 [default = false];
+    if (has_account_muted()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AccountInfo::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AccountInfo* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AccountInfo*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AccountInfo::MergeFrom(const AccountInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account_paid()) {
+      set_account_paid(from.account_paid());
+    }
+    if (from.has_country_id()) {
+      set_country_id(from.country_id());
+    }
+    if (from.has_battle_tag()) {
+      set_battle_tag(from.battle_tag());
+    }
+    if (from.has_manual_review()) {
+      set_manual_review(from.manual_review());
+    }
+    if (from.has_identity()) {
+      mutable_identity()->::bgs::protocol::Identity::MergeFrom(from.identity());
+    }
+    if (from.has_account_muted()) {
+      set_account_muted(from.account_muted());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AccountInfo::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AccountInfo::CopyFrom(const AccountInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AccountInfo::IsInitialized() const {
+
+  if (has_identity()) {
+    if (!this->identity().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AccountInfo::Swap(AccountInfo* other) {
+  if (other != this) {
+    std::swap(account_paid_, other->account_paid_);
+    std::swap(country_id_, other->country_id_);
+    std::swap(battle_tag_, other->battle_tag_);
+    std::swap(manual_review_, other->manual_review_);
+    std::swap(identity_, other->identity_);
+    std::swap(account_muted_, other->account_muted_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AccountInfo::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AccountInfo_descriptor_;
+  metadata.reflection = AccountInfo_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/entity_types.pb.h b/src/server/proto/Client/entity_types.pb.h
new file mode 100644
index 00000000000..1b01f75a9dc
--- /dev/null
+++ b/src/server/proto/Client/entity_types.pb.h
@@ -0,0 +1,739 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: entity_types.proto
+
+#ifndef PROTOBUF_entity_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_entity_5ftypes_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 "global_extensions/field_options.pb.h"
+#include "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_entity_5ftypes_2eproto();
+void protobuf_AssignDesc_entity_5ftypes_2eproto();
+void protobuf_ShutdownFile_entity_5ftypes_2eproto();
+
+class EntityId;
+class Identity;
+class AccountInfo;
+
+// ===================================================================
+
+class TC_SHARED_API EntityId : public ::google::protobuf::Message {
+ public:
+  EntityId();
+  virtual ~EntityId();
+
+  EntityId(const EntityId& from);
+
+  inline EntityId& operator=(const EntityId& 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 EntityId& default_instance();
+
+  void Swap(EntityId* other);
+
+  // implements Message ----------------------------------------------
+
+  EntityId* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const EntityId& from);
+  void MergeFrom(const EntityId& 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 fixed64 high = 1;
+  inline bool has_high() const;
+  inline void clear_high();
+  static const int kHighFieldNumber = 1;
+  inline ::google::protobuf::uint64 high() const;
+  inline void set_high(::google::protobuf::uint64 value);
+
+  // required fixed64 low = 2;
+  inline bool has_low() const;
+  inline void clear_low();
+  static const int kLowFieldNumber = 2;
+  inline ::google::protobuf::uint64 low() const;
+  inline void set_low(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.EntityId)
+ private:
+  inline void set_has_high();
+  inline void clear_has_high();
+  inline void set_has_low();
+  inline void clear_has_low();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 high_;
+  ::google::protobuf::uint64 low_;
+  friend void TC_SHARED_API protobuf_AddDesc_entity_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_entity_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_entity_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static EntityId* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API Identity : public ::google::protobuf::Message {
+ public:
+  Identity();
+  virtual ~Identity();
+
+  Identity(const Identity& from);
+
+  inline Identity& operator=(const Identity& 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 Identity& default_instance();
+
+  void Swap(Identity* other);
+
+  // implements Message ----------------------------------------------
+
+  Identity* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Identity& from);
+  void MergeFrom(const Identity& 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.EntityId account_id = 1;
+  inline bool has_account_id() const;
+  inline void clear_account_id();
+  static const int kAccountIdFieldNumber = 1;
+  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);
+
+  // 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.Identity)
+ private:
+  inline void set_has_account_id();
+  inline void clear_has_account_id();
+  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* account_id_;
+  ::bgs::protocol::EntityId* game_account_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_entity_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_entity_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_entity_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Identity* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AccountInfo : public ::google::protobuf::Message {
+ public:
+  AccountInfo();
+  virtual ~AccountInfo();
+
+  AccountInfo(const AccountInfo& from);
+
+  inline AccountInfo& operator=(const AccountInfo& 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 AccountInfo& default_instance();
+
+  void Swap(AccountInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  AccountInfo* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AccountInfo& from);
+  void MergeFrom(const AccountInfo& 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 bool account_paid = 1 [default = false];
+  inline bool has_account_paid() const;
+  inline void clear_account_paid();
+  static const int kAccountPaidFieldNumber = 1;
+  inline bool account_paid() const;
+  inline void set_account_paid(bool value);
+
+  // optional fixed32 country_id = 2 [default = 0];
+  inline bool has_country_id() const;
+  inline void clear_country_id();
+  static const int kCountryIdFieldNumber = 2;
+  inline ::google::protobuf::uint32 country_id() const;
+  inline void set_country_id(::google::protobuf::uint32 value);
+
+  // optional string battle_tag = 3;
+  inline bool has_battle_tag() const;
+  inline void clear_battle_tag();
+  static const int kBattleTagFieldNumber = 3;
+  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 bool manual_review = 4 [default = false];
+  inline bool has_manual_review() const;
+  inline void clear_manual_review();
+  static const int kManualReviewFieldNumber = 4;
+  inline bool manual_review() const;
+  inline void set_manual_review(bool value);
+
+  // optional .bgs.protocol.Identity identity = 5;
+  inline bool has_identity() const;
+  inline void clear_identity();
+  static const int kIdentityFieldNumber = 5;
+  inline const ::bgs::protocol::Identity& identity() const;
+  inline ::bgs::protocol::Identity* mutable_identity();
+  inline ::bgs::protocol::Identity* release_identity();
+  inline void set_allocated_identity(::bgs::protocol::Identity* identity);
+
+  // optional bool account_muted = 6 [default = false];
+  inline bool has_account_muted() const;
+  inline void clear_account_muted();
+  static const int kAccountMutedFieldNumber = 6;
+  inline bool account_muted() const;
+  inline void set_account_muted(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.AccountInfo)
+ private:
+  inline void set_has_account_paid();
+  inline void clear_has_account_paid();
+  inline void set_has_country_id();
+  inline void clear_has_country_id();
+  inline void set_has_battle_tag();
+  inline void clear_has_battle_tag();
+  inline void set_has_manual_review();
+  inline void clear_has_manual_review();
+  inline void set_has_identity();
+  inline void clear_has_identity();
+  inline void set_has_account_muted();
+  inline void clear_has_account_muted();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* battle_tag_;
+  ::google::protobuf::uint32 country_id_;
+  bool account_paid_;
+  bool manual_review_;
+  bool account_muted_;
+  ::bgs::protocol::Identity* identity_;
+  friend void TC_SHARED_API protobuf_AddDesc_entity_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_entity_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_entity_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static AccountInfo* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// EntityId
+
+// required fixed64 high = 1;
+inline bool EntityId::has_high() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void EntityId::set_has_high() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void EntityId::clear_has_high() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void EntityId::clear_high() {
+  high_ = GOOGLE_ULONGLONG(0);
+  clear_has_high();
+}
+inline ::google::protobuf::uint64 EntityId::high() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.EntityId.high)
+  return high_;
+}
+inline void EntityId::set_high(::google::protobuf::uint64 value) {
+  set_has_high();
+  high_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.EntityId.high)
+}
+
+// required fixed64 low = 2;
+inline bool EntityId::has_low() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void EntityId::set_has_low() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void EntityId::clear_has_low() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void EntityId::clear_low() {
+  low_ = GOOGLE_ULONGLONG(0);
+  clear_has_low();
+}
+inline ::google::protobuf::uint64 EntityId::low() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.EntityId.low)
+  return low_;
+}
+inline void EntityId::set_low(::google::protobuf::uint64 value) {
+  set_has_low();
+  low_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.EntityId.low)
+}
+
+// -------------------------------------------------------------------
+
+// Identity
+
+// optional .bgs.protocol.EntityId account_id = 1;
+inline bool Identity::has_account_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Identity::set_has_account_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Identity::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Identity::clear_account_id() {
+  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_account_id();
+}
+inline const ::bgs::protocol::EntityId& Identity::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Identity.account_id)
+  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
+}
+inline ::bgs::protocol::EntityId* Identity::mutable_account_id() {
+  set_has_account_id();
+  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Identity.account_id)
+  return account_id_;
+}
+inline ::bgs::protocol::EntityId* Identity::release_account_id() {
+  clear_has_account_id();
+  ::bgs::protocol::EntityId* temp = account_id_;
+  account_id_ = NULL;
+  return temp;
+}
+inline void Identity::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.Identity.account_id)
+}
+
+// optional .bgs.protocol.EntityId game_account_id = 2;
+inline bool Identity::has_game_account_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Identity::set_has_game_account_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Identity::clear_has_game_account_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Identity::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& Identity::game_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Identity.game_account_id)
+  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
+}
+inline ::bgs::protocol::EntityId* Identity::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.Identity.game_account_id)
+  return game_account_id_;
+}
+inline ::bgs::protocol::EntityId* Identity::release_game_account_id() {
+  clear_has_game_account_id();
+  ::bgs::protocol::EntityId* temp = game_account_id_;
+  game_account_id_ = NULL;
+  return temp;
+}
+inline void Identity::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.Identity.game_account_id)
+}
+
+// -------------------------------------------------------------------
+
+// AccountInfo
+
+// optional bool account_paid = 1 [default = false];
+inline bool AccountInfo::has_account_paid() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AccountInfo::set_has_account_paid() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AccountInfo::clear_has_account_paid() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AccountInfo::clear_account_paid() {
+  account_paid_ = false;
+  clear_has_account_paid();
+}
+inline bool AccountInfo::account_paid() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.account_paid)
+  return account_paid_;
+}
+inline void AccountInfo::set_account_paid(bool value) {
+  set_has_account_paid();
+  account_paid_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.AccountInfo.account_paid)
+}
+
+// optional fixed32 country_id = 2 [default = 0];
+inline bool AccountInfo::has_country_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AccountInfo::set_has_country_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AccountInfo::clear_has_country_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AccountInfo::clear_country_id() {
+  country_id_ = 0u;
+  clear_has_country_id();
+}
+inline ::google::protobuf::uint32 AccountInfo::country_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.country_id)
+  return country_id_;
+}
+inline void AccountInfo::set_country_id(::google::protobuf::uint32 value) {
+  set_has_country_id();
+  country_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.AccountInfo.country_id)
+}
+
+// optional string battle_tag = 3;
+inline bool AccountInfo::has_battle_tag() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AccountInfo::set_has_battle_tag() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AccountInfo::clear_has_battle_tag() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AccountInfo::clear_battle_tag() {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_->clear();
+  }
+  clear_has_battle_tag();
+}
+inline const ::std::string& AccountInfo::battle_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.battle_tag)
+  return *battle_tag_;
+}
+inline void AccountInfo::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.AccountInfo.battle_tag)
+}
+inline void AccountInfo::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.AccountInfo.battle_tag)
+}
+inline void AccountInfo::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.AccountInfo.battle_tag)
+}
+inline ::std::string* AccountInfo::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.AccountInfo.battle_tag)
+  return battle_tag_;
+}
+inline ::std::string* AccountInfo::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 AccountInfo::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.AccountInfo.battle_tag)
+}
+
+// optional bool manual_review = 4 [default = false];
+inline bool AccountInfo::has_manual_review() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void AccountInfo::set_has_manual_review() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void AccountInfo::clear_has_manual_review() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void AccountInfo::clear_manual_review() {
+  manual_review_ = false;
+  clear_has_manual_review();
+}
+inline bool AccountInfo::manual_review() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.manual_review)
+  return manual_review_;
+}
+inline void AccountInfo::set_manual_review(bool value) {
+  set_has_manual_review();
+  manual_review_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.AccountInfo.manual_review)
+}
+
+// optional .bgs.protocol.Identity identity = 5;
+inline bool AccountInfo::has_identity() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void AccountInfo::set_has_identity() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void AccountInfo::clear_has_identity() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void AccountInfo::clear_identity() {
+  if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear();
+  clear_has_identity();
+}
+inline const ::bgs::protocol::Identity& AccountInfo::identity() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.identity)
+  return identity_ != NULL ? *identity_ : *default_instance_->identity_;
+}
+inline ::bgs::protocol::Identity* AccountInfo::mutable_identity() {
+  set_has_identity();
+  if (identity_ == NULL) identity_ = new ::bgs::protocol::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.AccountInfo.identity)
+  return identity_;
+}
+inline ::bgs::protocol::Identity* AccountInfo::release_identity() {
+  clear_has_identity();
+  ::bgs::protocol::Identity* temp = identity_;
+  identity_ = NULL;
+  return temp;
+}
+inline void AccountInfo::set_allocated_identity(::bgs::protocol::Identity* identity) {
+  delete identity_;
+  identity_ = identity;
+  if (identity) {
+    set_has_identity();
+  } else {
+    clear_has_identity();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.AccountInfo.identity)
+}
+
+// optional bool account_muted = 6 [default = false];
+inline bool AccountInfo::has_account_muted() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void AccountInfo::set_has_account_muted() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void AccountInfo::clear_has_account_muted() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void AccountInfo::clear_account_muted() {
+  account_muted_ = false;
+  clear_has_account_muted();
+}
+inline bool AccountInfo::account_muted() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.AccountInfo.account_muted)
+  return account_muted_;
+}
+inline void AccountInfo::set_account_muted(bool value) {
+  set_has_account_muted();
+  account_muted_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.AccountInfo.account_muted)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_entity_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/friends_service.pb.cc b/src/server/proto/Client/friends_service.pb.cc
new file mode 100644
index 00000000000..73e19f22339
--- /dev/null
+++ b/src/server/proto/Client/friends_service.pb.cc
@@ -0,0 +1,5081 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: friends_service.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "friends_service.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+#include "BattlenetRpcErrorCodes.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace friends {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* SubscribeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscribeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SubscribeResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscribeResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UnsubscribeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UnsubscribeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GenericFriendRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GenericFriendRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GenericFriendResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GenericFriendResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AssignRoleRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AssignRoleRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ViewFriendsRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ViewFriendsRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ViewFriendsResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ViewFriendsResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UpdateFriendStateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UpdateFriendStateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* FriendNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  FriendNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UpdateFriendStateNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UpdateFriendStateNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* InvitationNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  InvitationNotification_reflection_ = NULL;
+const ::google::protobuf::ServiceDescriptor* FriendsService_descriptor_ = NULL;
+const ::google::protobuf::ServiceDescriptor* FriendsListener_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_friends_5fservice_2eproto() {
+  protobuf_AddDesc_friends_5fservice_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "friends_service.proto");
+  GOOGLE_CHECK(file != NULL);
+  SubscribeRequest_descriptor_ = file->message_type(0);
+  static const int SubscribeRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, object_id_),
+  };
+  SubscribeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscribeRequest_descriptor_,
+      SubscribeRequest::default_instance_,
+      SubscribeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscribeRequest));
+  SubscribeResponse_descriptor_ = file->message_type(1);
+  static const int SubscribeResponse_offsets_[7] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, max_friends_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, max_received_invitations_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, max_sent_invitations_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, friends_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, sent_invitations_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, received_invitations_),
+  };
+  SubscribeResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscribeResponse_descriptor_,
+      SubscribeResponse::default_instance_,
+      SubscribeResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscribeResponse));
+  UnsubscribeRequest_descriptor_ = file->message_type(2);
+  static const int UnsubscribeRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, object_id_),
+  };
+  UnsubscribeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UnsubscribeRequest_descriptor_,
+      UnsubscribeRequest::default_instance_,
+      UnsubscribeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UnsubscribeRequest));
+  GenericFriendRequest_descriptor_ = file->message_type(3);
+  static const int GenericFriendRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendRequest, target_id_),
+  };
+  GenericFriendRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GenericFriendRequest_descriptor_,
+      GenericFriendRequest::default_instance_,
+      GenericFriendRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GenericFriendRequest));
+  GenericFriendResponse_descriptor_ = file->message_type(4);
+  static const int GenericFriendResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendResponse, target_friend_),
+  };
+  GenericFriendResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GenericFriendResponse_descriptor_,
+      GenericFriendResponse::default_instance_,
+      GenericFriendResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericFriendResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GenericFriendResponse));
+  AssignRoleRequest_descriptor_ = file->message_type(5);
+  static const int AssignRoleRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, target_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, role_),
+  };
+  AssignRoleRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AssignRoleRequest_descriptor_,
+      AssignRoleRequest::default_instance_,
+      AssignRoleRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AssignRoleRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AssignRoleRequest));
+  ViewFriendsRequest_descriptor_ = file->message_type(6);
+  static const int ViewFriendsRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsRequest, target_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsRequest, role_),
+  };
+  ViewFriendsRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ViewFriendsRequest_descriptor_,
+      ViewFriendsRequest::default_instance_,
+      ViewFriendsRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ViewFriendsRequest));
+  ViewFriendsResponse_descriptor_ = file->message_type(7);
+  static const int ViewFriendsResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsResponse, friends_),
+  };
+  ViewFriendsResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ViewFriendsResponse_descriptor_,
+      ViewFriendsResponse::default_instance_,
+      ViewFriendsResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ViewFriendsResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ViewFriendsResponse));
+  UpdateFriendStateRequest_descriptor_ = file->message_type(8);
+  static const int UpdateFriendStateRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateRequest, target_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateRequest, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateRequest, attributes_epoch_),
+  };
+  UpdateFriendStateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UpdateFriendStateRequest_descriptor_,
+      UpdateFriendStateRequest::default_instance_,
+      UpdateFriendStateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UpdateFriendStateRequest));
+  FriendNotification_descriptor_ = file->message_type(9);
+  static const int FriendNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, target_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, game_account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, peer_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, account_id_),
+  };
+  FriendNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      FriendNotification_descriptor_,
+      FriendNotification::default_instance_,
+      FriendNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(FriendNotification));
+  UpdateFriendStateNotification_descriptor_ = file->message_type(10);
+  static const int UpdateFriendStateNotification_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, changed_friend_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, game_account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, peer_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, account_id_),
+  };
+  UpdateFriendStateNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UpdateFriendStateNotification_descriptor_,
+      UpdateFriendStateNotification::default_instance_,
+      UpdateFriendStateNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateFriendStateNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UpdateFriendStateNotification));
+  InvitationNotification_descriptor_ = file->message_type(11);
+  static const int InvitationNotification_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, invitation_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, game_account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, reason_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, peer_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, account_id_),
+  };
+  InvitationNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      InvitationNotification_descriptor_,
+      InvitationNotification::default_instance_,
+      InvitationNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(InvitationNotification));
+  FriendsService_descriptor_ = file->service(0);
+  FriendsListener_descriptor_ = file->service(1);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_friends_5fservice_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscribeRequest_descriptor_, &SubscribeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscribeResponse_descriptor_, &SubscribeResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UnsubscribeRequest_descriptor_, &UnsubscribeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GenericFriendRequest_descriptor_, &GenericFriendRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GenericFriendResponse_descriptor_, &GenericFriendResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AssignRoleRequest_descriptor_, &AssignRoleRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ViewFriendsRequest_descriptor_, &ViewFriendsRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ViewFriendsResponse_descriptor_, &ViewFriendsResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UpdateFriendStateRequest_descriptor_, &UpdateFriendStateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    FriendNotification_descriptor_, &FriendNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UpdateFriendStateNotification_descriptor_, &UpdateFriendStateNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    InvitationNotification_descriptor_, &InvitationNotification::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_friends_5fservice_2eproto() {
+  delete SubscribeRequest::default_instance_;
+  delete SubscribeRequest_reflection_;
+  delete SubscribeResponse::default_instance_;
+  delete SubscribeResponse_reflection_;
+  delete UnsubscribeRequest::default_instance_;
+  delete UnsubscribeRequest_reflection_;
+  delete GenericFriendRequest::default_instance_;
+  delete GenericFriendRequest_reflection_;
+  delete GenericFriendResponse::default_instance_;
+  delete GenericFriendResponse_reflection_;
+  delete AssignRoleRequest::default_instance_;
+  delete AssignRoleRequest_reflection_;
+  delete ViewFriendsRequest::default_instance_;
+  delete ViewFriendsRequest_reflection_;
+  delete ViewFriendsResponse::default_instance_;
+  delete ViewFriendsResponse_reflection_;
+  delete UpdateFriendStateRequest::default_instance_;
+  delete UpdateFriendStateRequest_reflection_;
+  delete FriendNotification::default_instance_;
+  delete FriendNotification_reflection_;
+  delete UpdateFriendStateNotification::default_instance_;
+  delete UpdateFriendStateNotification_reflection_;
+  delete InvitationNotification::default_instance_;
+  delete InvitationNotification_reflection_;
+}
+
+void protobuf_AddDesc_friends_5fservice_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::bgs::protocol::friends::v1::protobuf_AddDesc_friends_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_invitation_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_role_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\025friends_service.proto\022\027bgs.protocol.fr"
+    "iends.v1\032\025attribute_types.proto\032\022entity_"
+    "types.proto\032\023friends_types.proto\032\026invita"
+    "tion_types.proto\032\020role_types.proto\032\017rpc_"
+    "types.proto\"O\n\020SubscribeRequest\022(\n\010agent"
+    "_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022\021\n\tobj"
+    "ect_id\030\002 \002(\004\"\250\002\n\021SubscribeResponse\022\023\n\013ma"
+    "x_friends\030\001 \001(\r\022 \n\030max_received_invitati"
+    "ons\030\002 \001(\r\022\034\n\024max_sent_invitations\030\003 \001(\r\022"
+    " \n\004role\030\004 \003(\0132\022.bgs.protocol.Role\0220\n\007fri"
+    "ends\030\005 \003(\0132\037.bgs.protocol.friends.v1.Fri"
+    "end\0222\n\020sent_invitations\030\006 \003(\0132\030.bgs.prot"
+    "ocol.Invitation\0226\n\024received_invitations\030"
+    "\007 \003(\0132\030.bgs.protocol.Invitation\"Q\n\022Unsub"
+    "scribeRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.pr"
+    "otocol.EntityId\022\021\n\tobject_id\030\002 \001(\004\"k\n\024Ge"
+    "nericFriendRequest\022(\n\010agent_id\030\001 \001(\0132\026.b"
+    "gs.protocol.EntityId\022)\n\ttarget_id\030\002 \002(\0132"
+    "\026.bgs.protocol.EntityId\"O\n\025GenericFriend"
+    "Response\0226\n\rtarget_friend\030\001 \001(\0132\037.bgs.pr"
+    "otocol.friends.v1.Friend\"v\n\021AssignRoleRe"
+    "quest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.protocol.E"
+    "ntityId\022)\n\ttarget_id\030\002 \002(\0132\026.bgs.protoco"
+    "l.EntityId\022\014\n\004role\030\003 \003(\005\"{\n\022ViewFriendsR"
+    "equest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.protocol."
+    "EntityId\022)\n\ttarget_id\030\002 \002(\0132\026.bgs.protoc"
+    "ol.EntityId\022\020\n\004role\030\003 \003(\rB\002\020\001\"G\n\023ViewFri"
+    "endsResponse\0220\n\007friends\030\001 \003(\0132\037.bgs.prot"
+    "ocol.friends.v1.Friend\"\265\001\n\030UpdateFriendS"
+    "tateRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.prot"
+    "ocol.EntityId\022)\n\ttarget_id\030\002 \002(\0132\026.bgs.p"
+    "rotocol.EntityId\022*\n\tattribute\030\003 \003(\0132\027.bg"
+    "s.protocol.Attribute\022\030\n\020attributes_epoch"
+    "\030\004 \001(\004\"\311\001\n\022FriendNotification\022/\n\006target\030"
+    "\001 \002(\0132\037.bgs.protocol.friends.v1.Friend\022/"
+    "\n\017game_account_id\030\002 \001(\0132\026.bgs.protocol.E"
+    "ntityId\022%\n\004peer\030\004 \001(\0132\027.bgs.protocol.Pro"
+    "cessId\022*\n\naccount_id\030\005 \001(\0132\026.bgs.protoco"
+    "l.EntityId\"\334\001\n\035UpdateFriendStateNotifica"
+    "tion\0227\n\016changed_friend\030\001 \002(\0132\037.bgs.proto"
+    "col.friends.v1.Friend\022/\n\017game_account_id"
+    "\030\002 \001(\0132\026.bgs.protocol.EntityId\022%\n\004peer\030\004"
+    " \001(\0132\027.bgs.protocol.ProcessId\022*\n\naccount"
+    "_id\030\005 \001(\0132\026.bgs.protocol.EntityId\"\335\001\n\026In"
+    "vitationNotification\022,\n\ninvitation\030\001 \002(\013"
+    "2\030.bgs.protocol.Invitation\022/\n\017game_accou"
+    "nt_id\030\002 \001(\0132\026.bgs.protocol.EntityId\022\021\n\006r"
+    "eason\030\003 \001(\r:\0010\022%\n\004peer\030\004 \001(\0132\027.bgs.proto"
+    "col.ProcessId\022*\n\naccount_id\030\005 \001(\0132\026.bgs."
+    "protocol.EntityId2\264\t\n\016FriendsService\022h\n\t"
+    "Subscribe\022).bgs.protocol.friends.v1.Subs"
+    "cribeRequest\032*.bgs.protocol.friends.v1.S"
+    "ubscribeResponse\"\004\200\265\030\001\022Q\n\016SendInvitation"
+    "\022#.bgs.protocol.SendInvitationRequest\032\024."
+    "bgs.protocol.NoData\"\004\200\265\030\002\022V\n\020AcceptInvit"
+    "ation\022&.bgs.protocol.GenericInvitationRe"
+    "quest\032\024.bgs.protocol.NoData\"\004\200\265\030\003\022Y\n\020Rev"
+    "okeInvitation\022&.bgs.protocol.GenericInvi"
+    "tationRequest\032\024.bgs.protocol.NoData\"\007\210\002\001"
+    "\200\265\030\004\022W\n\021DeclineInvitation\022&.bgs.protocol"
+    ".GenericInvitationRequest\032\024.bgs.protocol"
+    ".NoData\"\004\200\265\030\005\022V\n\020IgnoreInvitation\022&.bgs."
+    "protocol.GenericInvitationRequest\032\024.bgs."
+    "protocol.NoData\"\004\200\265\030\006\022T\n\nAssignRole\022*.bg"
+    "s.protocol.friends.v1.AssignRoleRequest\032"
+    "\024.bgs.protocol.NoData\"\004\200\265\030\007\022s\n\014RemoveFri"
+    "end\022-.bgs.protocol.friends.v1.GenericFri"
+    "endRequest\032..bgs.protocol.friends.v1.Gen"
+    "ericFriendResponse\"\004\200\265\030\010\022n\n\013ViewFriends\022"
+    "+.bgs.protocol.friends.v1.ViewFriendsReq"
+    "uest\032,.bgs.protocol.friends.v1.ViewFrien"
+    "dsResponse\"\004\200\265\030\t\022b\n\021UpdateFriendState\0221."
+    "bgs.protocol.friends.v1.UpdateFriendStat"
+    "eRequest\032\024.bgs.protocol.NoData\"\004\200\265\030\n\022V\n\013"
+    "Unsubscribe\022+.bgs.protocol.friends.v1.Un"
+    "subscribeRequest\032\024.bgs.protocol.NoData\"\004"
+    "\200\265\030\013\022a\n\024RevokeAllInvitations\022-.bgs.proto"
+    "col.friends.v1.GenericFriendRequest\032\024.bg"
+    "s.protocol.NoData\"\004\200\265\030\014\032\'\312>$bnet.protoco"
+    "l.friends.FriendsService2\247\006\n\017FriendsList"
+    "ener\022]\n\rOnFriendAdded\022+.bgs.protocol.fri"
+    "ends.v1.FriendNotification\032\031.bgs.protoco"
+    "l.NO_RESPONSE\"\004\200\265\030\001\022_\n\017OnFriendRemoved\022+"
+    ".bgs.protocol.friends.v1.FriendNotificat"
+    "ion\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\002\022m\n\031"
+    "OnReceivedInvitationAdded\022/.bgs.protocol"
+    ".friends.v1.InvitationNotification\032\031.bgs"
+    ".protocol.NO_RESPONSE\"\004\200\265\030\003\022o\n\033OnReceive"
+    "dInvitationRemoved\022/.bgs.protocol.friend"
+    "s.v1.InvitationNotification\032\031.bgs.protoc"
+    "ol.NO_RESPONSE\"\004\200\265\030\004\022l\n\025OnSentInvitation"
+    "Added\022/.bgs.protocol.friends.v1.Invitati"
+    "onNotification\032\031.bgs.protocol.NO_RESPONS"
+    "E\"\007\210\002\001\200\265\030\005\022n\n\027OnSentInvitationRemoved\022/."
+    "bgs.protocol.friends.v1.InvitationNotifi"
+    "cation\032\031.bgs.protocol.NO_RESPONSE\"\007\210\002\001\200\265"
+    "\030\006\022n\n\023OnUpdateFriendState\0226.bgs.protocol"
+    ".friends.v1.UpdateFriendStateNotificatio"
+    "n\032\031.bgs.protocol.NO_RESPONSE\"\004\200\265\030\007\032&\312>#b"
+    "net.protocol.friends.FriendsNotifyB7\n\030bn"
+    "et.protocol.friends.v1B\023FriendsServicePr"
+    "otoH\001\200\001\000\210\001\001", 4051);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "friends_service.proto", &protobuf_RegisterTypes);
+  SubscribeRequest::default_instance_ = new SubscribeRequest();
+  SubscribeResponse::default_instance_ = new SubscribeResponse();
+  UnsubscribeRequest::default_instance_ = new UnsubscribeRequest();
+  GenericFriendRequest::default_instance_ = new GenericFriendRequest();
+  GenericFriendResponse::default_instance_ = new GenericFriendResponse();
+  AssignRoleRequest::default_instance_ = new AssignRoleRequest();
+  ViewFriendsRequest::default_instance_ = new ViewFriendsRequest();
+  ViewFriendsResponse::default_instance_ = new ViewFriendsResponse();
+  UpdateFriendStateRequest::default_instance_ = new UpdateFriendStateRequest();
+  FriendNotification::default_instance_ = new FriendNotification();
+  UpdateFriendStateNotification::default_instance_ = new UpdateFriendStateNotification();
+  InvitationNotification::default_instance_ = new InvitationNotification();
+  SubscribeRequest::default_instance_->InitAsDefaultInstance();
+  SubscribeResponse::default_instance_->InitAsDefaultInstance();
+  UnsubscribeRequest::default_instance_->InitAsDefaultInstance();
+  GenericFriendRequest::default_instance_->InitAsDefaultInstance();
+  GenericFriendResponse::default_instance_->InitAsDefaultInstance();
+  AssignRoleRequest::default_instance_->InitAsDefaultInstance();
+  ViewFriendsRequest::default_instance_->InitAsDefaultInstance();
+  ViewFriendsResponse::default_instance_->InitAsDefaultInstance();
+  UpdateFriendStateRequest::default_instance_->InitAsDefaultInstance();
+  FriendNotification::default_instance_->InitAsDefaultInstance();
+  UpdateFriendStateNotification::default_instance_->InitAsDefaultInstance();
+  InvitationNotification::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_friends_5fservice_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_friends_5fservice_2eproto {
+  StaticDescriptorInitializer_friends_5fservice_2eproto() {
+    protobuf_AddDesc_friends_5fservice_2eproto();
+  }
+} static_descriptor_initializer_friends_5fservice_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscribeRequest::kAgentIdFieldNumber;
+const int SubscribeRequest::kObjectIdFieldNumber;
+#endif  // !_MSC_VER
+
+SubscribeRequest::SubscribeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.SubscribeRequest)
+}
+
+void SubscribeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+SubscribeRequest::SubscribeRequest(const SubscribeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.SubscribeRequest)
+}
+
+void SubscribeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  object_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscribeRequest::~SubscribeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.SubscribeRequest)
+  SharedDtor();
+}
+
+void SubscribeRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void SubscribeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscribeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscribeRequest_descriptor_;
+}
+
+const SubscribeRequest& SubscribeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SubscribeRequest* SubscribeRequest::default_instance_ = NULL;
+
+SubscribeRequest* SubscribeRequest::New() const {
+  return new SubscribeRequest;
+}
+
+void SubscribeRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    object_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscribeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.SubscribeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_object_id;
+        break;
+      }
+
+      // required uint64 object_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_object_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &object_id_)));
+          set_has_object_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.SubscribeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.SubscribeRequest)
+  return false;
+#undef DO_
+}
+
+void SubscribeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.SubscribeRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required uint64 object_id = 2;
+  if (has_object_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->object_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.SubscribeRequest)
+}
+
+::google::protobuf::uint8* SubscribeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.SubscribeRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required uint64 object_id = 2;
+  if (has_object_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->object_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.SubscribeRequest)
+  return target;
+}
+
+int SubscribeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required uint64 object_id = 2;
+    if (has_object_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->object_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscribeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscribeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscribeRequest::MergeFrom(const SubscribeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_object_id()) {
+      set_object_id(from.object_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscribeRequest::CopyFrom(const SubscribeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscribeRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SubscribeRequest::Swap(SubscribeRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(object_id_, other->object_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscribeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscribeRequest_descriptor_;
+  metadata.reflection = SubscribeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscribeResponse::kMaxFriendsFieldNumber;
+const int SubscribeResponse::kMaxReceivedInvitationsFieldNumber;
+const int SubscribeResponse::kMaxSentInvitationsFieldNumber;
+const int SubscribeResponse::kRoleFieldNumber;
+const int SubscribeResponse::kFriendsFieldNumber;
+const int SubscribeResponse::kSentInvitationsFieldNumber;
+const int SubscribeResponse::kReceivedInvitationsFieldNumber;
+#endif  // !_MSC_VER
+
+SubscribeResponse::SubscribeResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.SubscribeResponse)
+}
+
+void SubscribeResponse::InitAsDefaultInstance() {
+}
+
+SubscribeResponse::SubscribeResponse(const SubscribeResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.SubscribeResponse)
+}
+
+void SubscribeResponse::SharedCtor() {
+  _cached_size_ = 0;
+  max_friends_ = 0u;
+  max_received_invitations_ = 0u;
+  max_sent_invitations_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscribeResponse::~SubscribeResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.SubscribeResponse)
+  SharedDtor();
+}
+
+void SubscribeResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void SubscribeResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscribeResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscribeResponse_descriptor_;
+}
+
+const SubscribeResponse& SubscribeResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SubscribeResponse* SubscribeResponse::default_instance_ = NULL;
+
+SubscribeResponse* SubscribeResponse::New() const {
+  return new SubscribeResponse;
+}
+
+void SubscribeResponse::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<SubscribeResponse*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(max_friends_, max_received_invitations_);
+    max_sent_invitations_ = 0u;
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  role_.Clear();
+  friends_.Clear();
+  sent_invitations_.Clear();
+  received_invitations_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscribeResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.SubscribeResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint32 max_friends = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &max_friends_)));
+          set_has_max_friends();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_max_received_invitations;
+        break;
+      }
+
+      // optional uint32 max_received_invitations = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_max_received_invitations:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &max_received_invitations_)));
+          set_has_max_received_invitations();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_max_sent_invitations;
+        break;
+      }
+
+      // optional uint32 max_sent_invitations = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_max_sent_invitations:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &max_sent_invitations_)));
+          set_has_max_sent_invitations();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_role;
+        break;
+      }
+
+      // repeated .bgs.protocol.Role role = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_role:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_role()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_role;
+        if (input->ExpectTag(42)) goto parse_friends;
+        break;
+      }
+
+      // repeated .bgs.protocol.friends.v1.Friend friends = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_friends:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_friends()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_friends;
+        if (input->ExpectTag(50)) goto parse_sent_invitations;
+        break;
+      }
+
+      // repeated .bgs.protocol.Invitation sent_invitations = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_sent_invitations:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_sent_invitations()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_sent_invitations;
+        if (input->ExpectTag(58)) goto parse_received_invitations;
+        break;
+      }
+
+      // repeated .bgs.protocol.Invitation received_invitations = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_received_invitations:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_received_invitations()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_received_invitations;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.SubscribeResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.SubscribeResponse)
+  return false;
+#undef DO_
+}
+
+void SubscribeResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.SubscribeResponse)
+  // optional uint32 max_friends = 1;
+  if (has_max_friends()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->max_friends(), output);
+  }
+
+  // optional uint32 max_received_invitations = 2;
+  if (has_max_received_invitations()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->max_received_invitations(), output);
+  }
+
+  // optional uint32 max_sent_invitations = 3;
+  if (has_max_sent_invitations()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->max_sent_invitations(), output);
+  }
+
+  // repeated .bgs.protocol.Role role = 4;
+  for (int i = 0; i < this->role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->role(i), output);
+  }
+
+  // repeated .bgs.protocol.friends.v1.Friend friends = 5;
+  for (int i = 0; i < this->friends_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->friends(i), output);
+  }
+
+  // repeated .bgs.protocol.Invitation sent_invitations = 6;
+  for (int i = 0; i < this->sent_invitations_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->sent_invitations(i), output);
+  }
+
+  // repeated .bgs.protocol.Invitation received_invitations = 7;
+  for (int i = 0; i < this->received_invitations_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      7, this->received_invitations(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.SubscribeResponse)
+}
+
+::google::protobuf::uint8* SubscribeResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.SubscribeResponse)
+  // optional uint32 max_friends = 1;
+  if (has_max_friends()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->max_friends(), target);
+  }
+
+  // optional uint32 max_received_invitations = 2;
+  if (has_max_received_invitations()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->max_received_invitations(), target);
+  }
+
+  // optional uint32 max_sent_invitations = 3;
+  if (has_max_sent_invitations()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->max_sent_invitations(), target);
+  }
+
+  // repeated .bgs.protocol.Role role = 4;
+  for (int i = 0; i < this->role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->role(i), target);
+  }
+
+  // repeated .bgs.protocol.friends.v1.Friend friends = 5;
+  for (int i = 0; i < this->friends_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->friends(i), target);
+  }
+
+  // repeated .bgs.protocol.Invitation sent_invitations = 6;
+  for (int i = 0; i < this->sent_invitations_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->sent_invitations(i), target);
+  }
+
+  // repeated .bgs.protocol.Invitation received_invitations = 7;
+  for (int i = 0; i < this->received_invitations_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        7, this->received_invitations(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.SubscribeResponse)
+  return target;
+}
+
+int SubscribeResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint32 max_friends = 1;
+    if (has_max_friends()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->max_friends());
+    }
+
+    // optional uint32 max_received_invitations = 2;
+    if (has_max_received_invitations()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->max_received_invitations());
+    }
+
+    // optional uint32 max_sent_invitations = 3;
+    if (has_max_sent_invitations()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->max_sent_invitations());
+    }
+
+  }
+  // repeated .bgs.protocol.Role role = 4;
+  total_size += 1 * this->role_size();
+  for (int i = 0; i < this->role_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->role(i));
+  }
+
+  // repeated .bgs.protocol.friends.v1.Friend friends = 5;
+  total_size += 1 * this->friends_size();
+  for (int i = 0; i < this->friends_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->friends(i));
+  }
+
+  // repeated .bgs.protocol.Invitation sent_invitations = 6;
+  total_size += 1 * this->sent_invitations_size();
+  for (int i = 0; i < this->sent_invitations_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->sent_invitations(i));
+  }
+
+  // repeated .bgs.protocol.Invitation received_invitations = 7;
+  total_size += 1 * this->received_invitations_size();
+  for (int i = 0; i < this->received_invitations_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->received_invitations(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscribeResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscribeResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscribeResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscribeResponse::MergeFrom(const SubscribeResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  role_.MergeFrom(from.role_);
+  friends_.MergeFrom(from.friends_);
+  sent_invitations_.MergeFrom(from.sent_invitations_);
+  received_invitations_.MergeFrom(from.received_invitations_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_max_friends()) {
+      set_max_friends(from.max_friends());
+    }
+    if (from.has_max_received_invitations()) {
+      set_max_received_invitations(from.max_received_invitations());
+    }
+    if (from.has_max_sent_invitations()) {
+      set_max_sent_invitations(from.max_sent_invitations());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscribeResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscribeResponse::CopyFrom(const SubscribeResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscribeResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->role())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->friends())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->sent_invitations())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->received_invitations())) return false;
+  return true;
+}
+
+void SubscribeResponse::Swap(SubscribeResponse* other) {
+  if (other != this) {
+    std::swap(max_friends_, other->max_friends_);
+    std::swap(max_received_invitations_, other->max_received_invitations_);
+    std::swap(max_sent_invitations_, other->max_sent_invitations_);
+    role_.Swap(&other->role_);
+    friends_.Swap(&other->friends_);
+    sent_invitations_.Swap(&other->sent_invitations_);
+    received_invitations_.Swap(&other->received_invitations_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscribeResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscribeResponse_descriptor_;
+  metadata.reflection = SubscribeResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UnsubscribeRequest::kAgentIdFieldNumber;
+const int UnsubscribeRequest::kObjectIdFieldNumber;
+#endif  // !_MSC_VER
+
+UnsubscribeRequest::UnsubscribeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.UnsubscribeRequest)
+}
+
+void UnsubscribeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+UnsubscribeRequest::UnsubscribeRequest(const UnsubscribeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.UnsubscribeRequest)
+}
+
+void UnsubscribeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  object_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UnsubscribeRequest::~UnsubscribeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.UnsubscribeRequest)
+  SharedDtor();
+}
+
+void UnsubscribeRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void UnsubscribeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UnsubscribeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UnsubscribeRequest_descriptor_;
+}
+
+const UnsubscribeRequest& UnsubscribeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+UnsubscribeRequest* UnsubscribeRequest::default_instance_ = NULL;
+
+UnsubscribeRequest* UnsubscribeRequest::New() const {
+  return new UnsubscribeRequest;
+}
+
+void UnsubscribeRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    object_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UnsubscribeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.UnsubscribeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_object_id;
+        break;
+      }
+
+      // optional uint64 object_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_object_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &object_id_)));
+          set_has_object_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.UnsubscribeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.UnsubscribeRequest)
+  return false;
+#undef DO_
+}
+
+void UnsubscribeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.UnsubscribeRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 object_id = 2;
+  if (has_object_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->object_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.UnsubscribeRequest)
+}
+
+::google::protobuf::uint8* UnsubscribeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.UnsubscribeRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 object_id = 2;
+  if (has_object_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->object_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.UnsubscribeRequest)
+  return target;
+}
+
+int UnsubscribeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 object_id = 2;
+    if (has_object_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->object_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UnsubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UnsubscribeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UnsubscribeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UnsubscribeRequest::MergeFrom(const UnsubscribeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_object_id()) {
+      set_object_id(from.object_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UnsubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UnsubscribeRequest::CopyFrom(const UnsubscribeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UnsubscribeRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UnsubscribeRequest::Swap(UnsubscribeRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(object_id_, other->object_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UnsubscribeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UnsubscribeRequest_descriptor_;
+  metadata.reflection = UnsubscribeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GenericFriendRequest::kAgentIdFieldNumber;
+const int GenericFriendRequest::kTargetIdFieldNumber;
+#endif  // !_MSC_VER
+
+GenericFriendRequest::GenericFriendRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.GenericFriendRequest)
+}
+
+void GenericFriendRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+GenericFriendRequest::GenericFriendRequest(const GenericFriendRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.GenericFriendRequest)
+}
+
+void GenericFriendRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  target_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GenericFriendRequest::~GenericFriendRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.GenericFriendRequest)
+  SharedDtor();
+}
+
+void GenericFriendRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete target_id_;
+  }
+}
+
+void GenericFriendRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GenericFriendRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GenericFriendRequest_descriptor_;
+}
+
+const GenericFriendRequest& GenericFriendRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GenericFriendRequest* GenericFriendRequest::default_instance_ = NULL;
+
+GenericFriendRequest* GenericFriendRequest::New() const {
+  return new GenericFriendRequest;
+}
+
+void GenericFriendRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GenericFriendRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.GenericFriendRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_target_id;
+        break;
+      }
+
+      // required .bgs.protocol.EntityId target_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_target_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.GenericFriendRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.GenericFriendRequest)
+  return false;
+#undef DO_
+}
+
+void GenericFriendRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.GenericFriendRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->target_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.GenericFriendRequest)
+}
+
+::google::protobuf::uint8* GenericFriendRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.GenericFriendRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->target_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.GenericFriendRequest)
+  return target;
+}
+
+int GenericFriendRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.EntityId target_id = 2;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GenericFriendRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GenericFriendRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GenericFriendRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GenericFriendRequest::MergeFrom(const GenericFriendRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GenericFriendRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GenericFriendRequest::CopyFrom(const GenericFriendRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GenericFriendRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GenericFriendRequest::Swap(GenericFriendRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(target_id_, other->target_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GenericFriendRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GenericFriendRequest_descriptor_;
+  metadata.reflection = GenericFriendRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GenericFriendResponse::kTargetFriendFieldNumber;
+#endif  // !_MSC_VER
+
+GenericFriendResponse::GenericFriendResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.GenericFriendResponse)
+}
+
+void GenericFriendResponse::InitAsDefaultInstance() {
+  target_friend_ = const_cast< ::bgs::protocol::friends::v1::Friend*>(&::bgs::protocol::friends::v1::Friend::default_instance());
+}
+
+GenericFriendResponse::GenericFriendResponse(const GenericFriendResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.GenericFriendResponse)
+}
+
+void GenericFriendResponse::SharedCtor() {
+  _cached_size_ = 0;
+  target_friend_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GenericFriendResponse::~GenericFriendResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.GenericFriendResponse)
+  SharedDtor();
+}
+
+void GenericFriendResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete target_friend_;
+  }
+}
+
+void GenericFriendResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GenericFriendResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GenericFriendResponse_descriptor_;
+}
+
+const GenericFriendResponse& GenericFriendResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GenericFriendResponse* GenericFriendResponse::default_instance_ = NULL;
+
+GenericFriendResponse* GenericFriendResponse::New() const {
+  return new GenericFriendResponse;
+}
+
+void GenericFriendResponse::Clear() {
+  if (has_target_friend()) {
+    if (target_friend_ != NULL) target_friend_->::bgs::protocol::friends::v1::Friend::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GenericFriendResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.GenericFriendResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.friends.v1.Friend target_friend = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_friend()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.GenericFriendResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.GenericFriendResponse)
+  return false;
+#undef DO_
+}
+
+void GenericFriendResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.GenericFriendResponse)
+  // optional .bgs.protocol.friends.v1.Friend target_friend = 1;
+  if (has_target_friend()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->target_friend(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.GenericFriendResponse)
+}
+
+::google::protobuf::uint8* GenericFriendResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.GenericFriendResponse)
+  // optional .bgs.protocol.friends.v1.Friend target_friend = 1;
+  if (has_target_friend()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->target_friend(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.GenericFriendResponse)
+  return target;
+}
+
+int GenericFriendResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.friends.v1.Friend target_friend = 1;
+    if (has_target_friend()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_friend());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GenericFriendResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GenericFriendResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GenericFriendResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GenericFriendResponse::MergeFrom(const GenericFriendResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_target_friend()) {
+      mutable_target_friend()->::bgs::protocol::friends::v1::Friend::MergeFrom(from.target_friend());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GenericFriendResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GenericFriendResponse::CopyFrom(const GenericFriendResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GenericFriendResponse::IsInitialized() const {
+
+  if (has_target_friend()) {
+    if (!this->target_friend().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GenericFriendResponse::Swap(GenericFriendResponse* other) {
+  if (other != this) {
+    std::swap(target_friend_, other->target_friend_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GenericFriendResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GenericFriendResponse_descriptor_;
+  metadata.reflection = GenericFriendResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AssignRoleRequest::kAgentIdFieldNumber;
+const int AssignRoleRequest::kTargetIdFieldNumber;
+const int AssignRoleRequest::kRoleFieldNumber;
+#endif  // !_MSC_VER
+
+AssignRoleRequest::AssignRoleRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.AssignRoleRequest)
+}
+
+void AssignRoleRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+AssignRoleRequest::AssignRoleRequest(const AssignRoleRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.AssignRoleRequest)
+}
+
+void AssignRoleRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  target_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AssignRoleRequest::~AssignRoleRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.AssignRoleRequest)
+  SharedDtor();
+}
+
+void AssignRoleRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete target_id_;
+  }
+}
+
+void AssignRoleRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AssignRoleRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AssignRoleRequest_descriptor_;
+}
+
+const AssignRoleRequest& AssignRoleRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+AssignRoleRequest* AssignRoleRequest::default_instance_ = NULL;
+
+AssignRoleRequest* AssignRoleRequest::New() const {
+  return new AssignRoleRequest;
+}
+
+void AssignRoleRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  role_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AssignRoleRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.AssignRoleRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_target_id;
+        break;
+      }
+
+      // required .bgs.protocol.EntityId target_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_target_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_role;
+        break;
+      }
+
+      // repeated int32 role = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 1, 24, input, this->mutable_role())));
+        } else if (tag == 26) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, this->mutable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_role;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.AssignRoleRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.AssignRoleRequest)
+  return false;
+#undef DO_
+}
+
+void AssignRoleRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.AssignRoleRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->target_id(), output);
+  }
+
+  // repeated int32 role = 3;
+  for (int i = 0; i < this->role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(
+      3, this->role(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.AssignRoleRequest)
+}
+
+::google::protobuf::uint8* AssignRoleRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.AssignRoleRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->target_id(), target);
+  }
+
+  // repeated int32 role = 3;
+  for (int i = 0; i < this->role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteInt32ToArray(3, this->role(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.AssignRoleRequest)
+  return target;
+}
+
+int AssignRoleRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.EntityId target_id = 2;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+  }
+  // repeated int32 role = 3;
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        Int32Size(this->role(i));
+    }
+    total_size += 1 * this->role_size() + data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AssignRoleRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AssignRoleRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AssignRoleRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AssignRoleRequest::MergeFrom(const AssignRoleRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  role_.MergeFrom(from.role_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AssignRoleRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AssignRoleRequest::CopyFrom(const AssignRoleRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AssignRoleRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AssignRoleRequest::Swap(AssignRoleRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(target_id_, other->target_id_);
+    role_.Swap(&other->role_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AssignRoleRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AssignRoleRequest_descriptor_;
+  metadata.reflection = AssignRoleRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ViewFriendsRequest::kAgentIdFieldNumber;
+const int ViewFriendsRequest::kTargetIdFieldNumber;
+const int ViewFriendsRequest::kRoleFieldNumber;
+#endif  // !_MSC_VER
+
+ViewFriendsRequest::ViewFriendsRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.ViewFriendsRequest)
+}
+
+void ViewFriendsRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+ViewFriendsRequest::ViewFriendsRequest(const ViewFriendsRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.ViewFriendsRequest)
+}
+
+void ViewFriendsRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  target_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ViewFriendsRequest::~ViewFriendsRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.ViewFriendsRequest)
+  SharedDtor();
+}
+
+void ViewFriendsRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete target_id_;
+  }
+}
+
+void ViewFriendsRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ViewFriendsRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ViewFriendsRequest_descriptor_;
+}
+
+const ViewFriendsRequest& ViewFriendsRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ViewFriendsRequest* ViewFriendsRequest::default_instance_ = NULL;
+
+ViewFriendsRequest* ViewFriendsRequest::New() const {
+  return new ViewFriendsRequest;
+}
+
+void ViewFriendsRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  role_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ViewFriendsRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.ViewFriendsRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_target_id;
+        break;
+      }
+
+      // required .bgs.protocol.EntityId target_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_target_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_role;
+        break;
+      }
+
+      // repeated uint32 role = 3 [packed = true];
+      case 3: {
+        if (tag == 26) {
+         parse_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_role())));
+        } else if (tag == 24) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 26, input, this->mutable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.ViewFriendsRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.ViewFriendsRequest)
+  return false;
+#undef DO_
+}
+
+void ViewFriendsRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.ViewFriendsRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->target_id(), output);
+  }
+
+  // repeated uint32 role = 3 [packed = true];
+  if (this->role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->role(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.ViewFriendsRequest)
+}
+
+::google::protobuf::uint8* ViewFriendsRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.ViewFriendsRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->target_id(), target);
+  }
+
+  // repeated uint32 role = 3 [packed = true];
+  if (this->role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      3,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->role(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.ViewFriendsRequest)
+  return target;
+}
+
+int ViewFriendsRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.EntityId target_id = 2;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+  }
+  // repeated uint32 role = 3 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ViewFriendsRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ViewFriendsRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ViewFriendsRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ViewFriendsRequest::MergeFrom(const ViewFriendsRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  role_.MergeFrom(from.role_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ViewFriendsRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ViewFriendsRequest::CopyFrom(const ViewFriendsRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ViewFriendsRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ViewFriendsRequest::Swap(ViewFriendsRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(target_id_, other->target_id_);
+    role_.Swap(&other->role_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ViewFriendsRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ViewFriendsRequest_descriptor_;
+  metadata.reflection = ViewFriendsRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ViewFriendsResponse::kFriendsFieldNumber;
+#endif  // !_MSC_VER
+
+ViewFriendsResponse::ViewFriendsResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.ViewFriendsResponse)
+}
+
+void ViewFriendsResponse::InitAsDefaultInstance() {
+}
+
+ViewFriendsResponse::ViewFriendsResponse(const ViewFriendsResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.ViewFriendsResponse)
+}
+
+void ViewFriendsResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ViewFriendsResponse::~ViewFriendsResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.ViewFriendsResponse)
+  SharedDtor();
+}
+
+void ViewFriendsResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ViewFriendsResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ViewFriendsResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ViewFriendsResponse_descriptor_;
+}
+
+const ViewFriendsResponse& ViewFriendsResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ViewFriendsResponse* ViewFriendsResponse::default_instance_ = NULL;
+
+ViewFriendsResponse* ViewFriendsResponse::New() const {
+  return new ViewFriendsResponse;
+}
+
+void ViewFriendsResponse::Clear() {
+  friends_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ViewFriendsResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.ViewFriendsResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.friends.v1.Friend friends = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_friends:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_friends()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_friends;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.ViewFriendsResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.ViewFriendsResponse)
+  return false;
+#undef DO_
+}
+
+void ViewFriendsResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.ViewFriendsResponse)
+  // repeated .bgs.protocol.friends.v1.Friend friends = 1;
+  for (int i = 0; i < this->friends_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->friends(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.ViewFriendsResponse)
+}
+
+::google::protobuf::uint8* ViewFriendsResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.ViewFriendsResponse)
+  // repeated .bgs.protocol.friends.v1.Friend friends = 1;
+  for (int i = 0; i < this->friends_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->friends(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.ViewFriendsResponse)
+  return target;
+}
+
+int ViewFriendsResponse::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.friends.v1.Friend friends = 1;
+  total_size += 1 * this->friends_size();
+  for (int i = 0; i < this->friends_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->friends(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ViewFriendsResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ViewFriendsResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ViewFriendsResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ViewFriendsResponse::MergeFrom(const ViewFriendsResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  friends_.MergeFrom(from.friends_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ViewFriendsResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ViewFriendsResponse::CopyFrom(const ViewFriendsResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ViewFriendsResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->friends())) return false;
+  return true;
+}
+
+void ViewFriendsResponse::Swap(ViewFriendsResponse* other) {
+  if (other != this) {
+    friends_.Swap(&other->friends_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ViewFriendsResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ViewFriendsResponse_descriptor_;
+  metadata.reflection = ViewFriendsResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UpdateFriendStateRequest::kAgentIdFieldNumber;
+const int UpdateFriendStateRequest::kTargetIdFieldNumber;
+const int UpdateFriendStateRequest::kAttributeFieldNumber;
+const int UpdateFriendStateRequest::kAttributesEpochFieldNumber;
+#endif  // !_MSC_VER
+
+UpdateFriendStateRequest::UpdateFriendStateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.UpdateFriendStateRequest)
+}
+
+void UpdateFriendStateRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+UpdateFriendStateRequest::UpdateFriendStateRequest(const UpdateFriendStateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.UpdateFriendStateRequest)
+}
+
+void UpdateFriendStateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  target_id_ = NULL;
+  attributes_epoch_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UpdateFriendStateRequest::~UpdateFriendStateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.UpdateFriendStateRequest)
+  SharedDtor();
+}
+
+void UpdateFriendStateRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete target_id_;
+  }
+}
+
+void UpdateFriendStateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UpdateFriendStateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UpdateFriendStateRequest_descriptor_;
+}
+
+const UpdateFriendStateRequest& UpdateFriendStateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+UpdateFriendStateRequest* UpdateFriendStateRequest::default_instance_ = NULL;
+
+UpdateFriendStateRequest* UpdateFriendStateRequest::New() const {
+  return new UpdateFriendStateRequest;
+}
+
+void UpdateFriendStateRequest::Clear() {
+  if (_has_bits_[0 / 32] & 11) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+    }
+    attributes_epoch_ = GOOGLE_ULONGLONG(0);
+  }
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UpdateFriendStateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.UpdateFriendStateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_target_id;
+        break;
+      }
+
+      // required .bgs.protocol.EntityId target_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_target_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.Attribute attribute = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        if (input->ExpectTag(32)) goto parse_attributes_epoch;
+        break;
+      }
+
+      // optional uint64 attributes_epoch = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_attributes_epoch:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &attributes_epoch_)));
+          set_has_attributes_epoch();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.UpdateFriendStateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.UpdateFriendStateRequest)
+  return false;
+#undef DO_
+}
+
+void UpdateFriendStateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.UpdateFriendStateRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->target_id(), output);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->attribute(i), output);
+  }
+
+  // optional uint64 attributes_epoch = 4;
+  if (has_attributes_epoch()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->attributes_epoch(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.UpdateFriendStateRequest)
+}
+
+::google::protobuf::uint8* UpdateFriendStateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.UpdateFriendStateRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->target_id(), target);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->attribute(i), target);
+  }
+
+  // optional uint64 attributes_epoch = 4;
+  if (has_attributes_epoch()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->attributes_epoch(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.UpdateFriendStateRequest)
+  return target;
+}
+
+int UpdateFriendStateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.EntityId target_id = 2;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+    // optional uint64 attributes_epoch = 4;
+    if (has_attributes_epoch()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->attributes_epoch());
+    }
+
+  }
+  // repeated .bgs.protocol.Attribute attribute = 3;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UpdateFriendStateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UpdateFriendStateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateFriendStateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UpdateFriendStateRequest::MergeFrom(const UpdateFriendStateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id());
+    }
+    if (from.has_attributes_epoch()) {
+      set_attributes_epoch(from.attributes_epoch());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UpdateFriendStateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UpdateFriendStateRequest::CopyFrom(const UpdateFriendStateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UpdateFriendStateRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
+  return true;
+}
+
+void UpdateFriendStateRequest::Swap(UpdateFriendStateRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(target_id_, other->target_id_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(attributes_epoch_, other->attributes_epoch_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UpdateFriendStateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UpdateFriendStateRequest_descriptor_;
+  metadata.reflection = UpdateFriendStateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int FriendNotification::kTargetFieldNumber;
+const int FriendNotification::kGameAccountIdFieldNumber;
+const int FriendNotification::kPeerFieldNumber;
+const int FriendNotification::kAccountIdFieldNumber;
+#endif  // !_MSC_VER
+
+FriendNotification::FriendNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.FriendNotification)
+}
+
+void FriendNotification::InitAsDefaultInstance() {
+  target_ = const_cast< ::bgs::protocol::friends::v1::Friend*>(&::bgs::protocol::friends::v1::Friend::default_instance());
+  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  peer_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+FriendNotification::FriendNotification(const FriendNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.FriendNotification)
+}
+
+void FriendNotification::SharedCtor() {
+  _cached_size_ = 0;
+  target_ = NULL;
+  game_account_id_ = NULL;
+  peer_ = NULL;
+  account_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+FriendNotification::~FriendNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.FriendNotification)
+  SharedDtor();
+}
+
+void FriendNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete target_;
+    delete game_account_id_;
+    delete peer_;
+    delete account_id_;
+  }
+}
+
+void FriendNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* FriendNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return FriendNotification_descriptor_;
+}
+
+const FriendNotification& FriendNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+FriendNotification* FriendNotification::default_instance_ = NULL;
+
+FriendNotification* FriendNotification::New() const {
+  return new FriendNotification;
+}
+
+void FriendNotification::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_target()) {
+      if (target_ != NULL) target_->::bgs::protocol::friends::v1::Friend::Clear();
+    }
+    if (has_game_account_id()) {
+      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_peer()) {
+      if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear();
+    }
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool FriendNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.FriendNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.friends.v1.Friend target = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_game_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId game_account_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_game_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_peer;
+        break;
+      }
+
+      // optional .bgs.protocol.ProcessId peer = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_peer:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_peer()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId account_id = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.FriendNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.FriendNotification)
+  return false;
+#undef DO_
+}
+
+void FriendNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.FriendNotification)
+  // required .bgs.protocol.friends.v1.Friend target = 1;
+  if (has_target()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->target(), output);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->game_account_id(), output);
+  }
+
+  // optional .bgs.protocol.ProcessId peer = 4;
+  if (has_peer()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->peer(), output);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 5;
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->account_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.FriendNotification)
+}
+
+::google::protobuf::uint8* FriendNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.FriendNotification)
+  // required .bgs.protocol.friends.v1.Friend target = 1;
+  if (has_target()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->target(), target);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->game_account_id(), target);
+  }
+
+  // optional .bgs.protocol.ProcessId peer = 4;
+  if (has_peer()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->peer(), target);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 5;
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->account_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.FriendNotification)
+  return target;
+}
+
+int FriendNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.friends.v1.Friend target = 1;
+    if (has_target()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target());
+    }
+
+    // optional .bgs.protocol.EntityId game_account_id = 2;
+    if (has_game_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_id());
+    }
+
+    // optional .bgs.protocol.ProcessId peer = 4;
+    if (has_peer()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->peer());
+    }
+
+    // optional .bgs.protocol.EntityId account_id = 5;
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FriendNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const FriendNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const FriendNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void FriendNotification::MergeFrom(const FriendNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_target()) {
+      mutable_target()->::bgs::protocol::friends::v1::Friend::MergeFrom(from.target());
+    }
+    if (from.has_game_account_id()) {
+      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+    }
+    if (from.has_peer()) {
+      mutable_peer()->::bgs::protocol::ProcessId::MergeFrom(from.peer());
+    }
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void FriendNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void FriendNotification::CopyFrom(const FriendNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FriendNotification::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_target()) {
+    if (!this->target().IsInitialized()) return false;
+  }
+  if (has_game_account_id()) {
+    if (!this->game_account_id().IsInitialized()) return false;
+  }
+  if (has_peer()) {
+    if (!this->peer().IsInitialized()) return false;
+  }
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void FriendNotification::Swap(FriendNotification* other) {
+  if (other != this) {
+    std::swap(target_, other->target_);
+    std::swap(game_account_id_, other->game_account_id_);
+    std::swap(peer_, other->peer_);
+    std::swap(account_id_, other->account_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata FriendNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = FriendNotification_descriptor_;
+  metadata.reflection = FriendNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UpdateFriendStateNotification::kChangedFriendFieldNumber;
+const int UpdateFriendStateNotification::kGameAccountIdFieldNumber;
+const int UpdateFriendStateNotification::kPeerFieldNumber;
+const int UpdateFriendStateNotification::kAccountIdFieldNumber;
+#endif  // !_MSC_VER
+
+UpdateFriendStateNotification::UpdateFriendStateNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.UpdateFriendStateNotification)
+}
+
+void UpdateFriendStateNotification::InitAsDefaultInstance() {
+  changed_friend_ = const_cast< ::bgs::protocol::friends::v1::Friend*>(&::bgs::protocol::friends::v1::Friend::default_instance());
+  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  peer_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+UpdateFriendStateNotification::UpdateFriendStateNotification(const UpdateFriendStateNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.UpdateFriendStateNotification)
+}
+
+void UpdateFriendStateNotification::SharedCtor() {
+  _cached_size_ = 0;
+  changed_friend_ = NULL;
+  game_account_id_ = NULL;
+  peer_ = NULL;
+  account_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UpdateFriendStateNotification::~UpdateFriendStateNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.UpdateFriendStateNotification)
+  SharedDtor();
+}
+
+void UpdateFriendStateNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete changed_friend_;
+    delete game_account_id_;
+    delete peer_;
+    delete account_id_;
+  }
+}
+
+void UpdateFriendStateNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UpdateFriendStateNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UpdateFriendStateNotification_descriptor_;
+}
+
+const UpdateFriendStateNotification& UpdateFriendStateNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+UpdateFriendStateNotification* UpdateFriendStateNotification::default_instance_ = NULL;
+
+UpdateFriendStateNotification* UpdateFriendStateNotification::New() const {
+  return new UpdateFriendStateNotification;
+}
+
+void UpdateFriendStateNotification::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_changed_friend()) {
+      if (changed_friend_ != NULL) changed_friend_->::bgs::protocol::friends::v1::Friend::Clear();
+    }
+    if (has_game_account_id()) {
+      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_peer()) {
+      if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear();
+    }
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UpdateFriendStateNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.UpdateFriendStateNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.friends.v1.Friend changed_friend = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_changed_friend()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_game_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId game_account_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_game_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_peer;
+        break;
+      }
+
+      // optional .bgs.protocol.ProcessId peer = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_peer:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_peer()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId account_id = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.UpdateFriendStateNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.UpdateFriendStateNotification)
+  return false;
+#undef DO_
+}
+
+void UpdateFriendStateNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.UpdateFriendStateNotification)
+  // required .bgs.protocol.friends.v1.Friend changed_friend = 1;
+  if (has_changed_friend()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->changed_friend(), output);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->game_account_id(), output);
+  }
+
+  // optional .bgs.protocol.ProcessId peer = 4;
+  if (has_peer()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->peer(), output);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 5;
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->account_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.UpdateFriendStateNotification)
+}
+
+::google::protobuf::uint8* UpdateFriendStateNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.UpdateFriendStateNotification)
+  // required .bgs.protocol.friends.v1.Friend changed_friend = 1;
+  if (has_changed_friend()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->changed_friend(), target);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->game_account_id(), target);
+  }
+
+  // optional .bgs.protocol.ProcessId peer = 4;
+  if (has_peer()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->peer(), target);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 5;
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->account_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.UpdateFriendStateNotification)
+  return target;
+}
+
+int UpdateFriendStateNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.friends.v1.Friend changed_friend = 1;
+    if (has_changed_friend()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->changed_friend());
+    }
+
+    // optional .bgs.protocol.EntityId game_account_id = 2;
+    if (has_game_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_id());
+    }
+
+    // optional .bgs.protocol.ProcessId peer = 4;
+    if (has_peer()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->peer());
+    }
+
+    // optional .bgs.protocol.EntityId account_id = 5;
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UpdateFriendStateNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UpdateFriendStateNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateFriendStateNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UpdateFriendStateNotification::MergeFrom(const UpdateFriendStateNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_changed_friend()) {
+      mutable_changed_friend()->::bgs::protocol::friends::v1::Friend::MergeFrom(from.changed_friend());
+    }
+    if (from.has_game_account_id()) {
+      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+    }
+    if (from.has_peer()) {
+      mutable_peer()->::bgs::protocol::ProcessId::MergeFrom(from.peer());
+    }
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UpdateFriendStateNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UpdateFriendStateNotification::CopyFrom(const UpdateFriendStateNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UpdateFriendStateNotification::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_changed_friend()) {
+    if (!this->changed_friend().IsInitialized()) return false;
+  }
+  if (has_game_account_id()) {
+    if (!this->game_account_id().IsInitialized()) return false;
+  }
+  if (has_peer()) {
+    if (!this->peer().IsInitialized()) return false;
+  }
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UpdateFriendStateNotification::Swap(UpdateFriendStateNotification* other) {
+  if (other != this) {
+    std::swap(changed_friend_, other->changed_friend_);
+    std::swap(game_account_id_, other->game_account_id_);
+    std::swap(peer_, other->peer_);
+    std::swap(account_id_, other->account_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UpdateFriendStateNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UpdateFriendStateNotification_descriptor_;
+  metadata.reflection = UpdateFriendStateNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int InvitationNotification::kInvitationFieldNumber;
+const int InvitationNotification::kGameAccountIdFieldNumber;
+const int InvitationNotification::kReasonFieldNumber;
+const int InvitationNotification::kPeerFieldNumber;
+const int InvitationNotification::kAccountIdFieldNumber;
+#endif  // !_MSC_VER
+
+InvitationNotification::InvitationNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.InvitationNotification)
+}
+
+void InvitationNotification::InitAsDefaultInstance() {
+  invitation_ = const_cast< ::bgs::protocol::Invitation*>(&::bgs::protocol::Invitation::default_instance());
+  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  peer_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+InvitationNotification::InvitationNotification(const InvitationNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.InvitationNotification)
+}
+
+void InvitationNotification::SharedCtor() {
+  _cached_size_ = 0;
+  invitation_ = NULL;
+  game_account_id_ = NULL;
+  reason_ = 0u;
+  peer_ = NULL;
+  account_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+InvitationNotification::~InvitationNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.InvitationNotification)
+  SharedDtor();
+}
+
+void InvitationNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete invitation_;
+    delete game_account_id_;
+    delete peer_;
+    delete account_id_;
+  }
+}
+
+void InvitationNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* InvitationNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return InvitationNotification_descriptor_;
+}
+
+const InvitationNotification& InvitationNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5fservice_2eproto();
+  return *default_instance_;
+}
+
+InvitationNotification* InvitationNotification::default_instance_ = NULL;
+
+InvitationNotification* InvitationNotification::New() const {
+  return new InvitationNotification;
+}
+
+void InvitationNotification::Clear() {
+  if (_has_bits_[0 / 32] & 31) {
+    if (has_invitation()) {
+      if (invitation_ != NULL) invitation_->::bgs::protocol::Invitation::Clear();
+    }
+    if (has_game_account_id()) {
+      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    reason_ = 0u;
+    if (has_peer()) {
+      if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear();
+    }
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool InvitationNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.InvitationNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.Invitation invitation = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_invitation()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_game_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId game_account_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_game_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_reason;
+        break;
+      }
+
+      // optional uint32 reason = 3 [default = 0];
+      case 3: {
+        if (tag == 24) {
+         parse_reason:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &reason_)));
+          set_has_reason();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_peer;
+        break;
+      }
+
+      // optional .bgs.protocol.ProcessId peer = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_peer:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_peer()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId account_id = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.InvitationNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.InvitationNotification)
+  return false;
+#undef DO_
+}
+
+void InvitationNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.InvitationNotification)
+  // required .bgs.protocol.Invitation invitation = 1;
+  if (has_invitation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->invitation(), output);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->game_account_id(), output);
+  }
+
+  // optional uint32 reason = 3 [default = 0];
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->reason(), output);
+  }
+
+  // optional .bgs.protocol.ProcessId peer = 4;
+  if (has_peer()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->peer(), output);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 5;
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->account_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.InvitationNotification)
+}
+
+::google::protobuf::uint8* InvitationNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.InvitationNotification)
+  // required .bgs.protocol.Invitation invitation = 1;
+  if (has_invitation()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->invitation(), target);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->game_account_id(), target);
+  }
+
+  // optional uint32 reason = 3 [default = 0];
+  if (has_reason()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->reason(), target);
+  }
+
+  // optional .bgs.protocol.ProcessId peer = 4;
+  if (has_peer()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->peer(), target);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 5;
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->account_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.InvitationNotification)
+  return target;
+}
+
+int InvitationNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.Invitation invitation = 1;
+    if (has_invitation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->invitation());
+    }
+
+    // optional .bgs.protocol.EntityId game_account_id = 2;
+    if (has_game_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_id());
+    }
+
+    // optional uint32 reason = 3 [default = 0];
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->reason());
+    }
+
+    // optional .bgs.protocol.ProcessId peer = 4;
+    if (has_peer()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->peer());
+    }
+
+    // optional .bgs.protocol.EntityId account_id = 5;
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void InvitationNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const InvitationNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const InvitationNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void InvitationNotification::MergeFrom(const InvitationNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_invitation()) {
+      mutable_invitation()->::bgs::protocol::Invitation::MergeFrom(from.invitation());
+    }
+    if (from.has_game_account_id()) {
+      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+    if (from.has_peer()) {
+      mutable_peer()->::bgs::protocol::ProcessId::MergeFrom(from.peer());
+    }
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void InvitationNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void InvitationNotification::CopyFrom(const InvitationNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool InvitationNotification::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_invitation()) {
+    if (!this->invitation().IsInitialized()) return false;
+  }
+  if (has_game_account_id()) {
+    if (!this->game_account_id().IsInitialized()) return false;
+  }
+  if (has_peer()) {
+    if (!this->peer().IsInitialized()) return false;
+  }
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void InvitationNotification::Swap(InvitationNotification* other) {
+  if (other != this) {
+    std::swap(invitation_, other->invitation_);
+    std::swap(game_account_id_, other->game_account_id_);
+    std::swap(reason_, other->reason_);
+    std::swap(peer_, other->peer_);
+    std::swap(account_id_, other->account_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata InvitationNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = InvitationNotification_descriptor_;
+  metadata.reflection = InvitationNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* FriendsService::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return FriendsService_descriptor_;
+}
+
+void FriendsService::Subscribe(::bgs::protocol::friends::v1::SubscribeRequest const* request, std::function<void(::bgs::protocol::friends::v1::SubscribeResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.Subscribe(bgs.protocol.friends.v1.SubscribeRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::friends::v1::SubscribeResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void FriendsService::SendInvitation(::bgs::protocol::SendInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.SendInvitation(bgs.protocol.SendInvitationRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 2, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void FriendsService::AcceptInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.AcceptInvitation(bgs.protocol.GenericInvitationRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 3, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void FriendsService::RevokeInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.RevokeInvitation(bgs.protocol.GenericInvitationRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 4, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void FriendsService::DeclineInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.DeclineInvitation(bgs.protocol.GenericInvitationRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 5, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void FriendsService::IgnoreInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.IgnoreInvitation(bgs.protocol.GenericInvitationRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 6, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void FriendsService::AssignRole(::bgs::protocol::friends::v1::AssignRoleRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.AssignRole(bgs.protocol.friends.v1.AssignRoleRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 7, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void FriendsService::RemoveFriend(::bgs::protocol::friends::v1::GenericFriendRequest const* request, std::function<void(::bgs::protocol::friends::v1::GenericFriendResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.RemoveFriend(bgs.protocol.friends.v1.GenericFriendRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 8, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::friends::v1::GenericFriendResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void FriendsService::ViewFriends(::bgs::protocol::friends::v1::ViewFriendsRequest const* request, std::function<void(::bgs::protocol::friends::v1::ViewFriendsResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.ViewFriends(bgs.protocol.friends.v1.ViewFriendsRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 9, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::friends::v1::ViewFriendsResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void FriendsService::UpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.UpdateFriendState(bgs.protocol.friends.v1.UpdateFriendStateRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 10, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void FriendsService::Unsubscribe(::bgs::protocol::friends::v1::UnsubscribeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.Unsubscribe(bgs.protocol.friends.v1.UnsubscribeRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 11, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void FriendsService::RevokeAllInvitations(::bgs::protocol::friends::v1::GenericFriendRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsService.RevokeAllInvitations(bgs.protocol.friends.v1.GenericFriendRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 12, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void FriendsService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::friends::v1::SubscribeRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.Subscribe server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::friends::v1::SubscribeResponse response;
+      uint32 status = HandleSubscribe(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.Subscribe(bgs.protocol.friends.v1.SubscribeRequest{ %s }) returned bgs.protocol.friends.v1.SubscribeResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 1, token, &response);
+      else
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    case 2: {
+      ::bgs::protocol::SendInvitationRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.SendInvitation server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleSendInvitation(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.SendInvitation(bgs.protocol.SendInvitationRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 2, token, &response);
+      else
+        SendResponse(service_hash_, 2, token, status);
+      break;
+    }
+    case 3: {
+      ::bgs::protocol::GenericInvitationRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.AcceptInvitation server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleAcceptInvitation(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.AcceptInvitation(bgs.protocol.GenericInvitationRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 3, token, &response);
+      else
+        SendResponse(service_hash_, 3, token, status);
+      break;
+    }
+    case 4: {
+      ::bgs::protocol::GenericInvitationRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.RevokeInvitation server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleRevokeInvitation(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.RevokeInvitation(bgs.protocol.GenericInvitationRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 4, token, &response);
+      else
+        SendResponse(service_hash_, 4, token, status);
+      break;
+    }
+    case 5: {
+      ::bgs::protocol::GenericInvitationRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.DeclineInvitation server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleDeclineInvitation(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.DeclineInvitation(bgs.protocol.GenericInvitationRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 5, token, &response);
+      else
+        SendResponse(service_hash_, 5, token, status);
+      break;
+    }
+    case 6: {
+      ::bgs::protocol::GenericInvitationRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.IgnoreInvitation server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleIgnoreInvitation(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.IgnoreInvitation(bgs.protocol.GenericInvitationRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 6, token, &response);
+      else
+        SendResponse(service_hash_, 6, token, status);
+      break;
+    }
+    case 7: {
+      ::bgs::protocol::friends::v1::AssignRoleRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.AssignRole server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleAssignRole(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.AssignRole(bgs.protocol.friends.v1.AssignRoleRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 7, token, &response);
+      else
+        SendResponse(service_hash_, 7, token, status);
+      break;
+    }
+    case 8: {
+      ::bgs::protocol::friends::v1::GenericFriendRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.RemoveFriend server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 8, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::friends::v1::GenericFriendResponse response;
+      uint32 status = HandleRemoveFriend(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.RemoveFriend(bgs.protocol.friends.v1.GenericFriendRequest{ %s }) returned bgs.protocol.friends.v1.GenericFriendResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 8, token, &response);
+      else
+        SendResponse(service_hash_, 8, token, status);
+      break;
+    }
+    case 9: {
+      ::bgs::protocol::friends::v1::ViewFriendsRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.ViewFriends server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 9, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::friends::v1::ViewFriendsResponse response;
+      uint32 status = HandleViewFriends(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.ViewFriends(bgs.protocol.friends.v1.ViewFriendsRequest{ %s }) returned bgs.protocol.friends.v1.ViewFriendsResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 9, token, &response);
+      else
+        SendResponse(service_hash_, 9, token, status);
+      break;
+    }
+    case 10: {
+      ::bgs::protocol::friends::v1::UpdateFriendStateRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.UpdateFriendState server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 10, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleUpdateFriendState(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.UpdateFriendState(bgs.protocol.friends.v1.UpdateFriendStateRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 10, token, &response);
+      else
+        SendResponse(service_hash_, 10, token, status);
+      break;
+    }
+    case 11: {
+      ::bgs::protocol::friends::v1::UnsubscribeRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.Unsubscribe server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 11, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleUnsubscribe(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.Unsubscribe(bgs.protocol.friends.v1.UnsubscribeRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 11, token, &response);
+      else
+        SendResponse(service_hash_, 11, token, status);
+      break;
+    }
+    case 12: {
+      ::bgs::protocol::friends::v1::GenericFriendRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsService.RevokeAllInvitations server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 12, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleRevokeAllInvitations(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsService.RevokeAllInvitations(bgs.protocol.friends.v1.GenericFriendRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 12, token, &response);
+      else
+        SendResponse(service_hash_, 12, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 FriendsService::HandleSubscribe(::bgs::protocol::friends::v1::SubscribeRequest const* request, ::bgs::protocol::friends::v1::SubscribeResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.Subscribe({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsService::HandleSendInvitation(::bgs::protocol::SendInvitationRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.SendInvitation({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsService::HandleAcceptInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.AcceptInvitation({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsService::HandleRevokeInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.RevokeInvitation({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsService::HandleDeclineInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.DeclineInvitation({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsService::HandleIgnoreInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.IgnoreInvitation({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsService::HandleAssignRole(::bgs::protocol::friends::v1::AssignRoleRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.AssignRole({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsService::HandleRemoveFriend(::bgs::protocol::friends::v1::GenericFriendRequest const* request, ::bgs::protocol::friends::v1::GenericFriendResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.RemoveFriend({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsService::HandleViewFriends(::bgs::protocol::friends::v1::ViewFriendsRequest const* request, ::bgs::protocol::friends::v1::ViewFriendsResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.ViewFriends({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsService::HandleUpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.UpdateFriendState({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsService::HandleUnsubscribe(::bgs::protocol::friends::v1::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.Unsubscribe({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsService::HandleRevokeAllInvitations(::bgs::protocol::friends::v1::GenericFriendRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsService.RevokeAllInvitations({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* FriendsListener::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return FriendsListener_descriptor_;
+}
+
+void FriendsListener::OnFriendAdded(::bgs::protocol::friends::v1::FriendNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnFriendAdded(bgs.protocol.friends.v1.FriendNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request);
+}
+
+void FriendsListener::OnFriendRemoved(::bgs::protocol::friends::v1::FriendNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnFriendRemoved(bgs.protocol.friends.v1.FriendNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 2, request);
+}
+
+void FriendsListener::OnReceivedInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnReceivedInvitationAdded(bgs.protocol.friends.v1.InvitationNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 3, request);
+}
+
+void FriendsListener::OnReceivedInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnReceivedInvitationRemoved(bgs.protocol.friends.v1.InvitationNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 4, request);
+}
+
+void FriendsListener::OnSentInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnSentInvitationAdded(bgs.protocol.friends.v1.InvitationNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 5, request);
+}
+
+void FriendsListener::OnSentInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnSentInvitationRemoved(bgs.protocol.friends.v1.InvitationNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 6, request);
+}
+
+void FriendsListener::OnUpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method FriendsListener.OnUpdateFriendState(bgs.protocol.friends.v1.UpdateFriendStateNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 7, request);
+}
+
+void FriendsListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::friends::v1::FriendNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsListener.OnFriendAdded server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnFriendAdded(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnFriendAdded(bgs.protocol.friends.v1.FriendNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    case 2: {
+      ::bgs::protocol::friends::v1::FriendNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsListener.OnFriendRemoved server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnFriendRemoved(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnFriendRemoved(bgs.protocol.friends.v1.FriendNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 2, token, status);
+      break;
+    }
+    case 3: {
+      ::bgs::protocol::friends::v1::InvitationNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsListener.OnReceivedInvitationAdded server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnReceivedInvitationAdded(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnReceivedInvitationAdded(bgs.protocol.friends.v1.InvitationNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 3, token, status);
+      break;
+    }
+    case 4: {
+      ::bgs::protocol::friends::v1::InvitationNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsListener.OnReceivedInvitationRemoved server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnReceivedInvitationRemoved(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnReceivedInvitationRemoved(bgs.protocol.friends.v1.InvitationNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 4, token, status);
+      break;
+    }
+    case 5: {
+      ::bgs::protocol::friends::v1::InvitationNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsListener.OnSentInvitationAdded server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnSentInvitationAdded(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnSentInvitationAdded(bgs.protocol.friends.v1.InvitationNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 5, token, status);
+      break;
+    }
+    case 6: {
+      ::bgs::protocol::friends::v1::InvitationNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsListener.OnSentInvitationRemoved server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnSentInvitationRemoved(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnSentInvitationRemoved(bgs.protocol.friends.v1.InvitationNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 6, token, status);
+      break;
+    }
+    case 7: {
+      ::bgs::protocol::friends::v1::UpdateFriendStateNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for FriendsListener.OnUpdateFriendState server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnUpdateFriendState(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method FriendsListener.OnUpdateFriendState(bgs.protocol.friends.v1.UpdateFriendStateNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 7, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 FriendsListener::HandleOnFriendAdded(::bgs::protocol::friends::v1::FriendNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsListener.OnFriendAdded({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsListener::HandleOnFriendRemoved(::bgs::protocol::friends::v1::FriendNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsListener.OnFriendRemoved({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsListener::HandleOnReceivedInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsListener.OnReceivedInvitationAdded({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsListener::HandleOnReceivedInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsListener.OnReceivedInvitationRemoved({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsListener::HandleOnSentInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsListener.OnSentInvitationAdded({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsListener::HandleOnSentInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsListener.OnSentInvitationRemoved({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 FriendsListener::HandleOnUpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method FriendsListener.OnUpdateFriendState({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace friends
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/friends_service.pb.h b/src/server/proto/Client/friends_service.pb.h
new file mode 100644
index 00000000000..9453c1df1d4
--- /dev/null
+++ b/src/server/proto/Client/friends_service.pb.h
@@ -0,0 +1,2856 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: friends_service.proto
+
+#ifndef PROTOBUF_friends_5fservice_2eproto__INCLUDED
+#define PROTOBUF_friends_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 "attribute_types.pb.h"
+#include "entity_types.pb.h"
+#include "friends_types.pb.h"
+#include "invitation_types.pb.h"
+#include "role_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 friends {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto();
+void protobuf_AssignDesc_friends_5fservice_2eproto();
+void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+class SubscribeRequest;
+class SubscribeResponse;
+class UnsubscribeRequest;
+class GenericFriendRequest;
+class GenericFriendResponse;
+class AssignRoleRequest;
+class ViewFriendsRequest;
+class ViewFriendsResponse;
+class UpdateFriendStateRequest;
+class FriendNotification;
+class UpdateFriendStateNotification;
+class InvitationNotification;
+
+// ===================================================================
+
+class TC_SHARED_API SubscribeRequest : public ::google::protobuf::Message {
+ public:
+  SubscribeRequest();
+  virtual ~SubscribeRequest();
+
+  SubscribeRequest(const SubscribeRequest& from);
+
+  inline SubscribeRequest& operator=(const SubscribeRequest& 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 SubscribeRequest& default_instance();
+
+  void Swap(SubscribeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscribeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscribeRequest& from);
+  void MergeFrom(const SubscribeRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required uint64 object_id = 2;
+  inline bool has_object_id() const;
+  inline void clear_object_id();
+  static const int kObjectIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 object_id() const;
+  inline void set_object_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.SubscribeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_object_id();
+  inline void clear_has_object_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::uint64 object_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscribeRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API SubscribeResponse : public ::google::protobuf::Message {
+ public:
+  SubscribeResponse();
+  virtual ~SubscribeResponse();
+
+  SubscribeResponse(const SubscribeResponse& from);
+
+  inline SubscribeResponse& operator=(const SubscribeResponse& 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 SubscribeResponse& default_instance();
+
+  void Swap(SubscribeResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscribeResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscribeResponse& from);
+  void MergeFrom(const SubscribeResponse& 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 max_friends = 1;
+  inline bool has_max_friends() const;
+  inline void clear_max_friends();
+  static const int kMaxFriendsFieldNumber = 1;
+  inline ::google::protobuf::uint32 max_friends() const;
+  inline void set_max_friends(::google::protobuf::uint32 value);
+
+  // optional uint32 max_received_invitations = 2;
+  inline bool has_max_received_invitations() const;
+  inline void clear_max_received_invitations();
+  static const int kMaxReceivedInvitationsFieldNumber = 2;
+  inline ::google::protobuf::uint32 max_received_invitations() const;
+  inline void set_max_received_invitations(::google::protobuf::uint32 value);
+
+  // optional uint32 max_sent_invitations = 3;
+  inline bool has_max_sent_invitations() const;
+  inline void clear_max_sent_invitations();
+  static const int kMaxSentInvitationsFieldNumber = 3;
+  inline ::google::protobuf::uint32 max_sent_invitations() const;
+  inline void set_max_sent_invitations(::google::protobuf::uint32 value);
+
+  // repeated .bgs.protocol.Role role = 4;
+  inline int role_size() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 4;
+  inline const ::bgs::protocol::Role& role(int index) const;
+  inline ::bgs::protocol::Role* mutable_role(int index);
+  inline ::bgs::protocol::Role* add_role();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role >&
+      role() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role >*
+      mutable_role();
+
+  // repeated .bgs.protocol.friends.v1.Friend friends = 5;
+  inline int friends_size() const;
+  inline void clear_friends();
+  static const int kFriendsFieldNumber = 5;
+  inline const ::bgs::protocol::friends::v1::Friend& friends(int index) const;
+  inline ::bgs::protocol::friends::v1::Friend* mutable_friends(int index);
+  inline ::bgs::protocol::friends::v1::Friend* add_friends();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >&
+      friends() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >*
+      mutable_friends();
+
+  // repeated .bgs.protocol.Invitation sent_invitations = 6;
+  inline int sent_invitations_size() const;
+  inline void clear_sent_invitations();
+  static const int kSentInvitationsFieldNumber = 6;
+  inline const ::bgs::protocol::Invitation& sent_invitations(int index) const;
+  inline ::bgs::protocol::Invitation* mutable_sent_invitations(int index);
+  inline ::bgs::protocol::Invitation* add_sent_invitations();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >&
+      sent_invitations() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >*
+      mutable_sent_invitations();
+
+  // repeated .bgs.protocol.Invitation received_invitations = 7;
+  inline int received_invitations_size() const;
+  inline void clear_received_invitations();
+  static const int kReceivedInvitationsFieldNumber = 7;
+  inline const ::bgs::protocol::Invitation& received_invitations(int index) const;
+  inline ::bgs::protocol::Invitation* mutable_received_invitations(int index);
+  inline ::bgs::protocol::Invitation* add_received_invitations();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >&
+      received_invitations() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >*
+      mutable_received_invitations();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.SubscribeResponse)
+ private:
+  inline void set_has_max_friends();
+  inline void clear_has_max_friends();
+  inline void set_has_max_received_invitations();
+  inline void clear_has_max_received_invitations();
+  inline void set_has_max_sent_invitations();
+  inline void clear_has_max_sent_invitations();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 max_friends_;
+  ::google::protobuf::uint32 max_received_invitations_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role > role_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend > friends_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation > sent_invitations_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation > received_invitations_;
+  ::google::protobuf::uint32 max_sent_invitations_;
+  friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscribeResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API UnsubscribeRequest : public ::google::protobuf::Message {
+ public:
+  UnsubscribeRequest();
+  virtual ~UnsubscribeRequest();
+
+  UnsubscribeRequest(const UnsubscribeRequest& from);
+
+  inline UnsubscribeRequest& operator=(const UnsubscribeRequest& 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 UnsubscribeRequest& default_instance();
+
+  void Swap(UnsubscribeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UnsubscribeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UnsubscribeRequest& from);
+  void MergeFrom(const UnsubscribeRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // optional uint64 object_id = 2;
+  inline bool has_object_id() const;
+  inline void clear_object_id();
+  static const int kObjectIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 object_id() const;
+  inline void set_object_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.UnsubscribeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_object_id();
+  inline void clear_has_object_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::uint64 object_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static UnsubscribeRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GenericFriendRequest : public ::google::protobuf::Message {
+ public:
+  GenericFriendRequest();
+  virtual ~GenericFriendRequest();
+
+  GenericFriendRequest(const GenericFriendRequest& from);
+
+  inline GenericFriendRequest& operator=(const GenericFriendRequest& 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 GenericFriendRequest& default_instance();
+
+  void Swap(GenericFriendRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GenericFriendRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GenericFriendRequest& from);
+  void MergeFrom(const GenericFriendRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& target_id() const;
+  inline ::bgs::protocol::EntityId* mutable_target_id();
+  inline ::bgs::protocol::EntityId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.GenericFriendRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::EntityId* target_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GenericFriendRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GenericFriendResponse : public ::google::protobuf::Message {
+ public:
+  GenericFriendResponse();
+  virtual ~GenericFriendResponse();
+
+  GenericFriendResponse(const GenericFriendResponse& from);
+
+  inline GenericFriendResponse& operator=(const GenericFriendResponse& 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 GenericFriendResponse& default_instance();
+
+  void Swap(GenericFriendResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GenericFriendResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GenericFriendResponse& from);
+  void MergeFrom(const GenericFriendResponse& 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.friends.v1.Friend target_friend = 1;
+  inline bool has_target_friend() const;
+  inline void clear_target_friend();
+  static const int kTargetFriendFieldNumber = 1;
+  inline const ::bgs::protocol::friends::v1::Friend& target_friend() const;
+  inline ::bgs::protocol::friends::v1::Friend* mutable_target_friend();
+  inline ::bgs::protocol::friends::v1::Friend* release_target_friend();
+  inline void set_allocated_target_friend(::bgs::protocol::friends::v1::Friend* target_friend);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.GenericFriendResponse)
+ private:
+  inline void set_has_target_friend();
+  inline void clear_has_target_friend();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::friends::v1::Friend* target_friend_;
+  friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GenericFriendResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AssignRoleRequest : public ::google::protobuf::Message {
+ public:
+  AssignRoleRequest();
+  virtual ~AssignRoleRequest();
+
+  AssignRoleRequest(const AssignRoleRequest& from);
+
+  inline AssignRoleRequest& operator=(const AssignRoleRequest& 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 AssignRoleRequest& default_instance();
+
+  void Swap(AssignRoleRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  AssignRoleRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AssignRoleRequest& from);
+  void MergeFrom(const AssignRoleRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& target_id() const;
+  inline ::bgs::protocol::EntityId* mutable_target_id();
+  inline ::bgs::protocol::EntityId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id);
+
+  // repeated int32 role = 3;
+  inline int role_size() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 3;
+  inline ::google::protobuf::int32 role(int index) const;
+  inline void set_role(int index, ::google::protobuf::int32 value);
+  inline void add_role(::google::protobuf::int32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+      role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+      mutable_role();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.AssignRoleRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::EntityId* target_id_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > role_;
+  friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static AssignRoleRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ViewFriendsRequest : public ::google::protobuf::Message {
+ public:
+  ViewFriendsRequest();
+  virtual ~ViewFriendsRequest();
+
+  ViewFriendsRequest(const ViewFriendsRequest& from);
+
+  inline ViewFriendsRequest& operator=(const ViewFriendsRequest& 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 ViewFriendsRequest& default_instance();
+
+  void Swap(ViewFriendsRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ViewFriendsRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ViewFriendsRequest& from);
+  void MergeFrom(const ViewFriendsRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& target_id() const;
+  inline ::bgs::protocol::EntityId* mutable_target_id();
+  inline ::bgs::protocol::EntityId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id);
+
+  // repeated uint32 role = 3 [packed = true];
+  inline int role_size() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 3;
+  inline ::google::protobuf::uint32 role(int index) const;
+  inline void set_role(int index, ::google::protobuf::uint32 value);
+  inline void add_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_role();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.ViewFriendsRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::EntityId* target_id_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
+  mutable int _role_cached_byte_size_;
+  friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ViewFriendsRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ViewFriendsResponse : public ::google::protobuf::Message {
+ public:
+  ViewFriendsResponse();
+  virtual ~ViewFriendsResponse();
+
+  ViewFriendsResponse(const ViewFriendsResponse& from);
+
+  inline ViewFriendsResponse& operator=(const ViewFriendsResponse& 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 ViewFriendsResponse& default_instance();
+
+  void Swap(ViewFriendsResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  ViewFriendsResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ViewFriendsResponse& from);
+  void MergeFrom(const ViewFriendsResponse& 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.friends.v1.Friend friends = 1;
+  inline int friends_size() const;
+  inline void clear_friends();
+  static const int kFriendsFieldNumber = 1;
+  inline const ::bgs::protocol::friends::v1::Friend& friends(int index) const;
+  inline ::bgs::protocol::friends::v1::Friend* mutable_friends(int index);
+  inline ::bgs::protocol::friends::v1::Friend* add_friends();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >&
+      friends() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >*
+      mutable_friends();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.ViewFriendsResponse)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend > friends_;
+  friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ViewFriendsResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API UpdateFriendStateRequest : public ::google::protobuf::Message {
+ public:
+  UpdateFriendStateRequest();
+  virtual ~UpdateFriendStateRequest();
+
+  UpdateFriendStateRequest(const UpdateFriendStateRequest& from);
+
+  inline UpdateFriendStateRequest& operator=(const UpdateFriendStateRequest& 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 UpdateFriendStateRequest& default_instance();
+
+  void Swap(UpdateFriendStateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UpdateFriendStateRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UpdateFriendStateRequest& from);
+  void MergeFrom(const UpdateFriendStateRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& target_id() const;
+  inline ::bgs::protocol::EntityId* mutable_target_id();
+  inline ::bgs::protocol::EntityId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id);
+
+  // repeated .bgs.protocol.Attribute attribute = 3;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 3;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
+  // optional uint64 attributes_epoch = 4;
+  inline bool has_attributes_epoch() const;
+  inline void clear_attributes_epoch();
+  static const int kAttributesEpochFieldNumber = 4;
+  inline ::google::protobuf::uint64 attributes_epoch() const;
+  inline void set_attributes_epoch(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.UpdateFriendStateRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+  inline void set_has_attributes_epoch();
+  inline void clear_has_attributes_epoch();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::EntityId* target_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
+  ::google::protobuf::uint64 attributes_epoch_;
+  friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static UpdateFriendStateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API FriendNotification : public ::google::protobuf::Message {
+ public:
+  FriendNotification();
+  virtual ~FriendNotification();
+
+  FriendNotification(const FriendNotification& from);
+
+  inline FriendNotification& operator=(const FriendNotification& 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 FriendNotification& default_instance();
+
+  void Swap(FriendNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  FriendNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const FriendNotification& from);
+  void MergeFrom(const FriendNotification& 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.friends.v1.Friend target = 1;
+  inline bool has_target() const;
+  inline void clear_target();
+  static const int kTargetFieldNumber = 1;
+  inline const ::bgs::protocol::friends::v1::Friend& target() const;
+  inline ::bgs::protocol::friends::v1::Friend* mutable_target();
+  inline ::bgs::protocol::friends::v1::Friend* release_target();
+  inline void set_allocated_target(::bgs::protocol::friends::v1::Friend* target);
+
+  // 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);
+
+  // optional .bgs.protocol.ProcessId peer = 4;
+  inline bool has_peer() const;
+  inline void clear_peer();
+  static const int kPeerFieldNumber = 4;
+  inline const ::bgs::protocol::ProcessId& peer() const;
+  inline ::bgs::protocol::ProcessId* mutable_peer();
+  inline ::bgs::protocol::ProcessId* release_peer();
+  inline void set_allocated_peer(::bgs::protocol::ProcessId* peer);
+
+  // optional .bgs.protocol.EntityId account_id = 5;
+  inline bool has_account_id() const;
+  inline void clear_account_id();
+  static const int kAccountIdFieldNumber = 5;
+  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);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.FriendNotification)
+ private:
+  inline void set_has_target();
+  inline void clear_has_target();
+  inline void set_has_game_account_id();
+  inline void clear_has_game_account_id();
+  inline void set_has_peer();
+  inline void clear_has_peer();
+  inline void set_has_account_id();
+  inline void clear_has_account_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::friends::v1::Friend* target_;
+  ::bgs::protocol::EntityId* game_account_id_;
+  ::bgs::protocol::ProcessId* peer_;
+  ::bgs::protocol::EntityId* account_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static FriendNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API UpdateFriendStateNotification : public ::google::protobuf::Message {
+ public:
+  UpdateFriendStateNotification();
+  virtual ~UpdateFriendStateNotification();
+
+  UpdateFriendStateNotification(const UpdateFriendStateNotification& from);
+
+  inline UpdateFriendStateNotification& operator=(const UpdateFriendStateNotification& 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 UpdateFriendStateNotification& default_instance();
+
+  void Swap(UpdateFriendStateNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  UpdateFriendStateNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UpdateFriendStateNotification& from);
+  void MergeFrom(const UpdateFriendStateNotification& 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.friends.v1.Friend changed_friend = 1;
+  inline bool has_changed_friend() const;
+  inline void clear_changed_friend();
+  static const int kChangedFriendFieldNumber = 1;
+  inline const ::bgs::protocol::friends::v1::Friend& changed_friend() const;
+  inline ::bgs::protocol::friends::v1::Friend* mutable_changed_friend();
+  inline ::bgs::protocol::friends::v1::Friend* release_changed_friend();
+  inline void set_allocated_changed_friend(::bgs::protocol::friends::v1::Friend* changed_friend);
+
+  // 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);
+
+  // optional .bgs.protocol.ProcessId peer = 4;
+  inline bool has_peer() const;
+  inline void clear_peer();
+  static const int kPeerFieldNumber = 4;
+  inline const ::bgs::protocol::ProcessId& peer() const;
+  inline ::bgs::protocol::ProcessId* mutable_peer();
+  inline ::bgs::protocol::ProcessId* release_peer();
+  inline void set_allocated_peer(::bgs::protocol::ProcessId* peer);
+
+  // optional .bgs.protocol.EntityId account_id = 5;
+  inline bool has_account_id() const;
+  inline void clear_account_id();
+  static const int kAccountIdFieldNumber = 5;
+  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);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.UpdateFriendStateNotification)
+ private:
+  inline void set_has_changed_friend();
+  inline void clear_has_changed_friend();
+  inline void set_has_game_account_id();
+  inline void clear_has_game_account_id();
+  inline void set_has_peer();
+  inline void clear_has_peer();
+  inline void set_has_account_id();
+  inline void clear_has_account_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::friends::v1::Friend* changed_friend_;
+  ::bgs::protocol::EntityId* game_account_id_;
+  ::bgs::protocol::ProcessId* peer_;
+  ::bgs::protocol::EntityId* account_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static UpdateFriendStateNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API InvitationNotification : public ::google::protobuf::Message {
+ public:
+  InvitationNotification();
+  virtual ~InvitationNotification();
+
+  InvitationNotification(const InvitationNotification& from);
+
+  inline InvitationNotification& operator=(const InvitationNotification& 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 InvitationNotification& default_instance();
+
+  void Swap(InvitationNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  InvitationNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const InvitationNotification& from);
+  void MergeFrom(const InvitationNotification& 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.Invitation invitation = 1;
+  inline bool has_invitation() const;
+  inline void clear_invitation();
+  static const int kInvitationFieldNumber = 1;
+  inline const ::bgs::protocol::Invitation& invitation() const;
+  inline ::bgs::protocol::Invitation* mutable_invitation();
+  inline ::bgs::protocol::Invitation* release_invitation();
+  inline void set_allocated_invitation(::bgs::protocol::Invitation* invitation);
+
+  // 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);
+
+  // optional uint32 reason = 3 [default = 0];
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 3;
+  inline ::google::protobuf::uint32 reason() const;
+  inline void set_reason(::google::protobuf::uint32 value);
+
+  // optional .bgs.protocol.ProcessId peer = 4;
+  inline bool has_peer() const;
+  inline void clear_peer();
+  static const int kPeerFieldNumber = 4;
+  inline const ::bgs::protocol::ProcessId& peer() const;
+  inline ::bgs::protocol::ProcessId* mutable_peer();
+  inline ::bgs::protocol::ProcessId* release_peer();
+  inline void set_allocated_peer(::bgs::protocol::ProcessId* peer);
+
+  // optional .bgs.protocol.EntityId account_id = 5;
+  inline bool has_account_id() const;
+  inline void clear_account_id();
+  static const int kAccountIdFieldNumber = 5;
+  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);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.InvitationNotification)
+ private:
+  inline void set_has_invitation();
+  inline void clear_has_invitation();
+  inline void set_has_game_account_id();
+  inline void clear_has_game_account_id();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+  inline void set_has_peer();
+  inline void clear_has_peer();
+  inline void set_has_account_id();
+  inline void clear_has_account_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::Invitation* invitation_;
+  ::bgs::protocol::EntityId* game_account_id_;
+  ::bgs::protocol::ProcessId* peer_;
+  ::bgs::protocol::EntityId* account_id_;
+  ::google::protobuf::uint32 reason_;
+  friend void TC_SHARED_API protobuf_AddDesc_friends_5fservice_2eproto();
+  friend void protobuf_AssignDesc_friends_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_friends_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static InvitationNotification* default_instance_;
+};
+// ===================================================================
+
+class TC_SHARED_API FriendsService : public ServiceBase
+{
+ public:
+
+  template<typename HashSelector>
+  explicit FriendsService(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  typedef std::integral_constant<uint32, 0xA3DDB1BDu> OriginalHash;
+  typedef std::integral_constant<uint32, 0xABDFED63u> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void Subscribe(::bgs::protocol::friends::v1::SubscribeRequest const* request, std::function<void(::bgs::protocol::friends::v1::SubscribeResponse const*)> responseCallback);
+  void SendInvitation(::bgs::protocol::SendInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void AcceptInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void RevokeInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void DeclineInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void IgnoreInvitation(::bgs::protocol::GenericInvitationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void AssignRole(::bgs::protocol::friends::v1::AssignRoleRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void RemoveFriend(::bgs::protocol::friends::v1::GenericFriendRequest const* request, std::function<void(::bgs::protocol::friends::v1::GenericFriendResponse const*)> responseCallback);
+  void ViewFriends(::bgs::protocol::friends::v1::ViewFriendsRequest const* request, std::function<void(::bgs::protocol::friends::v1::ViewFriendsResponse const*)> responseCallback);
+  void UpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void Unsubscribe(::bgs::protocol::friends::v1::UnsubscribeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void RevokeAllInvitations(::bgs::protocol::friends::v1::GenericFriendRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleSubscribe(::bgs::protocol::friends::v1::SubscribeRequest const* request, ::bgs::protocol::friends::v1::SubscribeResponse* response);
+  virtual uint32 HandleSendInvitation(::bgs::protocol::SendInvitationRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleAcceptInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleRevokeInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleDeclineInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleIgnoreInvitation(::bgs::protocol::GenericInvitationRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleAssignRole(::bgs::protocol::friends::v1::AssignRoleRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleRemoveFriend(::bgs::protocol::friends::v1::GenericFriendRequest const* request, ::bgs::protocol::friends::v1::GenericFriendResponse* response);
+  virtual uint32 HandleViewFriends(::bgs::protocol::friends::v1::ViewFriendsRequest const* request, ::bgs::protocol::friends::v1::ViewFriendsResponse* response);
+  virtual uint32 HandleUpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleUnsubscribe(::bgs::protocol::friends::v1::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleRevokeAllInvitations(::bgs::protocol::friends::v1::GenericFriendRequest const* request, ::bgs::protocol::NoData* response);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FriendsService);
+};
+
+// -------------------------------------------------------------------
+
+class TC_SHARED_API FriendsListener : public ServiceBase
+{
+ public:
+
+  template<typename HashSelector>
+  explicit FriendsListener(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  typedef std::integral_constant<uint32, 0x6F259A13u> OriginalHash;
+  typedef std::integral_constant<uint32, 0xA6717548u> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void OnFriendAdded(::bgs::protocol::friends::v1::FriendNotification const* request);
+  void OnFriendRemoved(::bgs::protocol::friends::v1::FriendNotification const* request);
+  void OnReceivedInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request);
+  void OnReceivedInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request);
+  void OnSentInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request);
+  void OnSentInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request);
+  void OnUpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateNotification const* request);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleOnFriendAdded(::bgs::protocol::friends::v1::FriendNotification const* request);
+  virtual uint32 HandleOnFriendRemoved(::bgs::protocol::friends::v1::FriendNotification const* request);
+  virtual uint32 HandleOnReceivedInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request);
+  virtual uint32 HandleOnReceivedInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request);
+  virtual uint32 HandleOnSentInvitationAdded(::bgs::protocol::friends::v1::InvitationNotification const* request);
+  virtual uint32 HandleOnSentInvitationRemoved(::bgs::protocol::friends::v1::InvitationNotification const* request);
+  virtual uint32 HandleOnUpdateFriendState(::bgs::protocol::friends::v1::UpdateFriendStateNotification const* request);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FriendsListener);
+};
+
+// ===================================================================
+
+
+// ===================================================================
+
+// SubscribeRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool SubscribeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SubscribeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SubscribeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SubscribeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& SubscribeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* SubscribeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SubscribeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* SubscribeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SubscribeRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.SubscribeRequest.agent_id)
+}
+
+// required uint64 object_id = 2;
+inline bool SubscribeRequest::has_object_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SubscribeRequest::set_has_object_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SubscribeRequest::clear_has_object_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SubscribeRequest::clear_object_id() {
+  object_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_object_id();
+}
+inline ::google::protobuf::uint64 SubscribeRequest::object_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeRequest.object_id)
+  return object_id_;
+}
+inline void SubscribeRequest::set_object_id(::google::protobuf::uint64 value) {
+  set_has_object_id();
+  object_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.SubscribeRequest.object_id)
+}
+
+// -------------------------------------------------------------------
+
+// SubscribeResponse
+
+// optional uint32 max_friends = 1;
+inline bool SubscribeResponse::has_max_friends() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SubscribeResponse::set_has_max_friends() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SubscribeResponse::clear_has_max_friends() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SubscribeResponse::clear_max_friends() {
+  max_friends_ = 0u;
+  clear_has_max_friends();
+}
+inline ::google::protobuf::uint32 SubscribeResponse::max_friends() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.max_friends)
+  return max_friends_;
+}
+inline void SubscribeResponse::set_max_friends(::google::protobuf::uint32 value) {
+  set_has_max_friends();
+  max_friends_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.SubscribeResponse.max_friends)
+}
+
+// optional uint32 max_received_invitations = 2;
+inline bool SubscribeResponse::has_max_received_invitations() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SubscribeResponse::set_has_max_received_invitations() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SubscribeResponse::clear_has_max_received_invitations() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SubscribeResponse::clear_max_received_invitations() {
+  max_received_invitations_ = 0u;
+  clear_has_max_received_invitations();
+}
+inline ::google::protobuf::uint32 SubscribeResponse::max_received_invitations() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.max_received_invitations)
+  return max_received_invitations_;
+}
+inline void SubscribeResponse::set_max_received_invitations(::google::protobuf::uint32 value) {
+  set_has_max_received_invitations();
+  max_received_invitations_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.SubscribeResponse.max_received_invitations)
+}
+
+// optional uint32 max_sent_invitations = 3;
+inline bool SubscribeResponse::has_max_sent_invitations() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SubscribeResponse::set_has_max_sent_invitations() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SubscribeResponse::clear_has_max_sent_invitations() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SubscribeResponse::clear_max_sent_invitations() {
+  max_sent_invitations_ = 0u;
+  clear_has_max_sent_invitations();
+}
+inline ::google::protobuf::uint32 SubscribeResponse::max_sent_invitations() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.max_sent_invitations)
+  return max_sent_invitations_;
+}
+inline void SubscribeResponse::set_max_sent_invitations(::google::protobuf::uint32 value) {
+  set_has_max_sent_invitations();
+  max_sent_invitations_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.SubscribeResponse.max_sent_invitations)
+}
+
+// repeated .bgs.protocol.Role role = 4;
+inline int SubscribeResponse::role_size() const {
+  return role_.size();
+}
+inline void SubscribeResponse::clear_role() {
+  role_.Clear();
+}
+inline const ::bgs::protocol::Role& SubscribeResponse::role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.role)
+  return role_.Get(index);
+}
+inline ::bgs::protocol::Role* SubscribeResponse::mutable_role(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SubscribeResponse.role)
+  return role_.Mutable(index);
+}
+inline ::bgs::protocol::Role* SubscribeResponse::add_role() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.SubscribeResponse.role)
+  return role_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role >&
+SubscribeResponse::role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.SubscribeResponse.role)
+  return role_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role >*
+SubscribeResponse::mutable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.SubscribeResponse.role)
+  return &role_;
+}
+
+// repeated .bgs.protocol.friends.v1.Friend friends = 5;
+inline int SubscribeResponse::friends_size() const {
+  return friends_.size();
+}
+inline void SubscribeResponse::clear_friends() {
+  friends_.Clear();
+}
+inline const ::bgs::protocol::friends::v1::Friend& SubscribeResponse::friends(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.friends)
+  return friends_.Get(index);
+}
+inline ::bgs::protocol::friends::v1::Friend* SubscribeResponse::mutable_friends(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SubscribeResponse.friends)
+  return friends_.Mutable(index);
+}
+inline ::bgs::protocol::friends::v1::Friend* SubscribeResponse::add_friends() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.SubscribeResponse.friends)
+  return friends_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >&
+SubscribeResponse::friends() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.SubscribeResponse.friends)
+  return friends_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >*
+SubscribeResponse::mutable_friends() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.SubscribeResponse.friends)
+  return &friends_;
+}
+
+// repeated .bgs.protocol.Invitation sent_invitations = 6;
+inline int SubscribeResponse::sent_invitations_size() const {
+  return sent_invitations_.size();
+}
+inline void SubscribeResponse::clear_sent_invitations() {
+  sent_invitations_.Clear();
+}
+inline const ::bgs::protocol::Invitation& SubscribeResponse::sent_invitations(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.sent_invitations)
+  return sent_invitations_.Get(index);
+}
+inline ::bgs::protocol::Invitation* SubscribeResponse::mutable_sent_invitations(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SubscribeResponse.sent_invitations)
+  return sent_invitations_.Mutable(index);
+}
+inline ::bgs::protocol::Invitation* SubscribeResponse::add_sent_invitations() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.SubscribeResponse.sent_invitations)
+  return sent_invitations_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >&
+SubscribeResponse::sent_invitations() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.SubscribeResponse.sent_invitations)
+  return sent_invitations_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >*
+SubscribeResponse::mutable_sent_invitations() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.SubscribeResponse.sent_invitations)
+  return &sent_invitations_;
+}
+
+// repeated .bgs.protocol.Invitation received_invitations = 7;
+inline int SubscribeResponse::received_invitations_size() const {
+  return received_invitations_.size();
+}
+inline void SubscribeResponse::clear_received_invitations() {
+  received_invitations_.Clear();
+}
+inline const ::bgs::protocol::Invitation& SubscribeResponse::received_invitations(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.SubscribeResponse.received_invitations)
+  return received_invitations_.Get(index);
+}
+inline ::bgs::protocol::Invitation* SubscribeResponse::mutable_received_invitations(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.SubscribeResponse.received_invitations)
+  return received_invitations_.Mutable(index);
+}
+inline ::bgs::protocol::Invitation* SubscribeResponse::add_received_invitations() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.SubscribeResponse.received_invitations)
+  return received_invitations_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >&
+SubscribeResponse::received_invitations() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.SubscribeResponse.received_invitations)
+  return received_invitations_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >*
+SubscribeResponse::mutable_received_invitations() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.SubscribeResponse.received_invitations)
+  return &received_invitations_;
+}
+
+// -------------------------------------------------------------------
+
+// UnsubscribeRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool UnsubscribeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UnsubscribeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UnsubscribeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UnsubscribeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& UnsubscribeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UnsubscribeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* UnsubscribeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UnsubscribeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* UnsubscribeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UnsubscribeRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UnsubscribeRequest.agent_id)
+}
+
+// optional uint64 object_id = 2;
+inline bool UnsubscribeRequest::has_object_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UnsubscribeRequest::set_has_object_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UnsubscribeRequest::clear_has_object_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UnsubscribeRequest::clear_object_id() {
+  object_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_object_id();
+}
+inline ::google::protobuf::uint64 UnsubscribeRequest::object_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UnsubscribeRequest.object_id)
+  return object_id_;
+}
+inline void UnsubscribeRequest::set_object_id(::google::protobuf::uint64 value) {
+  set_has_object_id();
+  object_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.UnsubscribeRequest.object_id)
+}
+
+// -------------------------------------------------------------------
+
+// GenericFriendRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool GenericFriendRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GenericFriendRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GenericFriendRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GenericFriendRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& GenericFriendRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.GenericFriendRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* GenericFriendRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.GenericFriendRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* GenericFriendRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GenericFriendRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.GenericFriendRequest.agent_id)
+}
+
+// required .bgs.protocol.EntityId target_id = 2;
+inline bool GenericFriendRequest::has_target_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GenericFriendRequest::set_has_target_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GenericFriendRequest::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GenericFriendRequest::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::EntityId& GenericFriendRequest::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.GenericFriendRequest.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::EntityId* GenericFriendRequest::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.GenericFriendRequest.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::EntityId* GenericFriendRequest::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::EntityId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void GenericFriendRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.GenericFriendRequest.target_id)
+}
+
+// -------------------------------------------------------------------
+
+// GenericFriendResponse
+
+// optional .bgs.protocol.friends.v1.Friend target_friend = 1;
+inline bool GenericFriendResponse::has_target_friend() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GenericFriendResponse::set_has_target_friend() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GenericFriendResponse::clear_has_target_friend() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GenericFriendResponse::clear_target_friend() {
+  if (target_friend_ != NULL) target_friend_->::bgs::protocol::friends::v1::Friend::Clear();
+  clear_has_target_friend();
+}
+inline const ::bgs::protocol::friends::v1::Friend& GenericFriendResponse::target_friend() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.GenericFriendResponse.target_friend)
+  return target_friend_ != NULL ? *target_friend_ : *default_instance_->target_friend_;
+}
+inline ::bgs::protocol::friends::v1::Friend* GenericFriendResponse::mutable_target_friend() {
+  set_has_target_friend();
+  if (target_friend_ == NULL) target_friend_ = new ::bgs::protocol::friends::v1::Friend;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.GenericFriendResponse.target_friend)
+  return target_friend_;
+}
+inline ::bgs::protocol::friends::v1::Friend* GenericFriendResponse::release_target_friend() {
+  clear_has_target_friend();
+  ::bgs::protocol::friends::v1::Friend* temp = target_friend_;
+  target_friend_ = NULL;
+  return temp;
+}
+inline void GenericFriendResponse::set_allocated_target_friend(::bgs::protocol::friends::v1::Friend* target_friend) {
+  delete target_friend_;
+  target_friend_ = target_friend;
+  if (target_friend) {
+    set_has_target_friend();
+  } else {
+    clear_has_target_friend();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.GenericFriendResponse.target_friend)
+}
+
+// -------------------------------------------------------------------
+
+// AssignRoleRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool AssignRoleRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void AssignRoleRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void AssignRoleRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void AssignRoleRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& AssignRoleRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.AssignRoleRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* AssignRoleRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.AssignRoleRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* AssignRoleRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void AssignRoleRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.AssignRoleRequest.agent_id)
+}
+
+// required .bgs.protocol.EntityId target_id = 2;
+inline bool AssignRoleRequest::has_target_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AssignRoleRequest::set_has_target_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AssignRoleRequest::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AssignRoleRequest::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::EntityId& AssignRoleRequest::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.AssignRoleRequest.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::EntityId* AssignRoleRequest::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.AssignRoleRequest.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::EntityId* AssignRoleRequest::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::EntityId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void AssignRoleRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.AssignRoleRequest.target_id)
+}
+
+// repeated int32 role = 3;
+inline int AssignRoleRequest::role_size() const {
+  return role_.size();
+}
+inline void AssignRoleRequest::clear_role() {
+  role_.Clear();
+}
+inline ::google::protobuf::int32 AssignRoleRequest::role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.AssignRoleRequest.role)
+  return role_.Get(index);
+}
+inline void AssignRoleRequest::set_role(int index, ::google::protobuf::int32 value) {
+  role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.AssignRoleRequest.role)
+}
+inline void AssignRoleRequest::add_role(::google::protobuf::int32 value) {
+  role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.AssignRoleRequest.role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+AssignRoleRequest::role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.AssignRoleRequest.role)
+  return role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+AssignRoleRequest::mutable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.AssignRoleRequest.role)
+  return &role_;
+}
+
+// -------------------------------------------------------------------
+
+// ViewFriendsRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool ViewFriendsRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ViewFriendsRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ViewFriendsRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ViewFriendsRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& ViewFriendsRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ViewFriendsRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* ViewFriendsRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.ViewFriendsRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* ViewFriendsRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void ViewFriendsRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.ViewFriendsRequest.agent_id)
+}
+
+// required .bgs.protocol.EntityId target_id = 2;
+inline bool ViewFriendsRequest::has_target_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ViewFriendsRequest::set_has_target_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ViewFriendsRequest::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ViewFriendsRequest::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::EntityId& ViewFriendsRequest::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ViewFriendsRequest.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::EntityId* ViewFriendsRequest::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.ViewFriendsRequest.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::EntityId* ViewFriendsRequest::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::EntityId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void ViewFriendsRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.ViewFriendsRequest.target_id)
+}
+
+// repeated uint32 role = 3 [packed = true];
+inline int ViewFriendsRequest::role_size() const {
+  return role_.size();
+}
+inline void ViewFriendsRequest::clear_role() {
+  role_.Clear();
+}
+inline ::google::protobuf::uint32 ViewFriendsRequest::role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ViewFriendsRequest.role)
+  return role_.Get(index);
+}
+inline void ViewFriendsRequest::set_role(int index, ::google::protobuf::uint32 value) {
+  role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.ViewFriendsRequest.role)
+}
+inline void ViewFriendsRequest::add_role(::google::protobuf::uint32 value) {
+  role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.ViewFriendsRequest.role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+ViewFriendsRequest::role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.ViewFriendsRequest.role)
+  return role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+ViewFriendsRequest::mutable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.ViewFriendsRequest.role)
+  return &role_;
+}
+
+// -------------------------------------------------------------------
+
+// ViewFriendsResponse
+
+// repeated .bgs.protocol.friends.v1.Friend friends = 1;
+inline int ViewFriendsResponse::friends_size() const {
+  return friends_.size();
+}
+inline void ViewFriendsResponse::clear_friends() {
+  friends_.Clear();
+}
+inline const ::bgs::protocol::friends::v1::Friend& ViewFriendsResponse::friends(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.ViewFriendsResponse.friends)
+  return friends_.Get(index);
+}
+inline ::bgs::protocol::friends::v1::Friend* ViewFriendsResponse::mutable_friends(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.ViewFriendsResponse.friends)
+  return friends_.Mutable(index);
+}
+inline ::bgs::protocol::friends::v1::Friend* ViewFriendsResponse::add_friends() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.ViewFriendsResponse.friends)
+  return friends_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >&
+ViewFriendsResponse::friends() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.ViewFriendsResponse.friends)
+  return friends_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::friends::v1::Friend >*
+ViewFriendsResponse::mutable_friends() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.ViewFriendsResponse.friends)
+  return &friends_;
+}
+
+// -------------------------------------------------------------------
+
+// UpdateFriendStateRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool UpdateFriendStateRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UpdateFriendStateRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UpdateFriendStateRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UpdateFriendStateRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& UpdateFriendStateRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateFriendStateRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UpdateFriendStateRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateFriendStateRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UpdateFriendStateRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UpdateFriendStateRequest.agent_id)
+}
+
+// required .bgs.protocol.EntityId target_id = 2;
+inline bool UpdateFriendStateRequest::has_target_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UpdateFriendStateRequest::set_has_target_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UpdateFriendStateRequest::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UpdateFriendStateRequest::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::EntityId& UpdateFriendStateRequest::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateRequest.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateFriendStateRequest::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UpdateFriendStateRequest.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateFriendStateRequest::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::EntityId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void UpdateFriendStateRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UpdateFriendStateRequest.target_id)
+}
+
+// repeated .bgs.protocol.Attribute attribute = 3;
+inline int UpdateFriendStateRequest::attribute_size() const {
+  return attribute_.size();
+}
+inline void UpdateFriendStateRequest::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::Attribute& UpdateFriendStateRequest::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateRequest.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::Attribute* UpdateFriendStateRequest::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UpdateFriendStateRequest.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* UpdateFriendStateRequest::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.UpdateFriendStateRequest.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+UpdateFriendStateRequest::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.UpdateFriendStateRequest.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+UpdateFriendStateRequest::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.UpdateFriendStateRequest.attribute)
+  return &attribute_;
+}
+
+// optional uint64 attributes_epoch = 4;
+inline bool UpdateFriendStateRequest::has_attributes_epoch() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void UpdateFriendStateRequest::set_has_attributes_epoch() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void UpdateFriendStateRequest::clear_has_attributes_epoch() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void UpdateFriendStateRequest::clear_attributes_epoch() {
+  attributes_epoch_ = GOOGLE_ULONGLONG(0);
+  clear_has_attributes_epoch();
+}
+inline ::google::protobuf::uint64 UpdateFriendStateRequest::attributes_epoch() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateRequest.attributes_epoch)
+  return attributes_epoch_;
+}
+inline void UpdateFriendStateRequest::set_attributes_epoch(::google::protobuf::uint64 value) {
+  set_has_attributes_epoch();
+  attributes_epoch_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.UpdateFriendStateRequest.attributes_epoch)
+}
+
+// -------------------------------------------------------------------
+
+// FriendNotification
+
+// required .bgs.protocol.friends.v1.Friend target = 1;
+inline bool FriendNotification::has_target() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FriendNotification::set_has_target() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FriendNotification::clear_has_target() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FriendNotification::clear_target() {
+  if (target_ != NULL) target_->::bgs::protocol::friends::v1::Friend::Clear();
+  clear_has_target();
+}
+inline const ::bgs::protocol::friends::v1::Friend& FriendNotification::target() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendNotification.target)
+  return target_ != NULL ? *target_ : *default_instance_->target_;
+}
+inline ::bgs::protocol::friends::v1::Friend* FriendNotification::mutable_target() {
+  set_has_target();
+  if (target_ == NULL) target_ = new ::bgs::protocol::friends::v1::Friend;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendNotification.target)
+  return target_;
+}
+inline ::bgs::protocol::friends::v1::Friend* FriendNotification::release_target() {
+  clear_has_target();
+  ::bgs::protocol::friends::v1::Friend* temp = target_;
+  target_ = NULL;
+  return temp;
+}
+inline void FriendNotification::set_allocated_target(::bgs::protocol::friends::v1::Friend* target) {
+  delete target_;
+  target_ = target;
+  if (target) {
+    set_has_target();
+  } else {
+    clear_has_target();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendNotification.target)
+}
+
+// optional .bgs.protocol.EntityId game_account_id = 2;
+inline bool FriendNotification::has_game_account_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void FriendNotification::set_has_game_account_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void FriendNotification::clear_has_game_account_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void FriendNotification::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& FriendNotification::game_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendNotification.game_account_id)
+  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
+}
+inline ::bgs::protocol::EntityId* FriendNotification::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.friends.v1.FriendNotification.game_account_id)
+  return game_account_id_;
+}
+inline ::bgs::protocol::EntityId* FriendNotification::release_game_account_id() {
+  clear_has_game_account_id();
+  ::bgs::protocol::EntityId* temp = game_account_id_;
+  game_account_id_ = NULL;
+  return temp;
+}
+inline void FriendNotification::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.friends.v1.FriendNotification.game_account_id)
+}
+
+// optional .bgs.protocol.ProcessId peer = 4;
+inline bool FriendNotification::has_peer() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void FriendNotification::set_has_peer() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void FriendNotification::clear_has_peer() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void FriendNotification::clear_peer() {
+  if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear();
+  clear_has_peer();
+}
+inline const ::bgs::protocol::ProcessId& FriendNotification::peer() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendNotification.peer)
+  return peer_ != NULL ? *peer_ : *default_instance_->peer_;
+}
+inline ::bgs::protocol::ProcessId* FriendNotification::mutable_peer() {
+  set_has_peer();
+  if (peer_ == NULL) peer_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendNotification.peer)
+  return peer_;
+}
+inline ::bgs::protocol::ProcessId* FriendNotification::release_peer() {
+  clear_has_peer();
+  ::bgs::protocol::ProcessId* temp = peer_;
+  peer_ = NULL;
+  return temp;
+}
+inline void FriendNotification::set_allocated_peer(::bgs::protocol::ProcessId* peer) {
+  delete peer_;
+  peer_ = peer;
+  if (peer) {
+    set_has_peer();
+  } else {
+    clear_has_peer();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendNotification.peer)
+}
+
+// optional .bgs.protocol.EntityId account_id = 5;
+inline bool FriendNotification::has_account_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void FriendNotification::set_has_account_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void FriendNotification::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void FriendNotification::clear_account_id() {
+  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_account_id();
+}
+inline const ::bgs::protocol::EntityId& FriendNotification::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendNotification.account_id)
+  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
+}
+inline ::bgs::protocol::EntityId* FriendNotification::mutable_account_id() {
+  set_has_account_id();
+  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendNotification.account_id)
+  return account_id_;
+}
+inline ::bgs::protocol::EntityId* FriendNotification::release_account_id() {
+  clear_has_account_id();
+  ::bgs::protocol::EntityId* temp = account_id_;
+  account_id_ = NULL;
+  return temp;
+}
+inline void FriendNotification::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.friends.v1.FriendNotification.account_id)
+}
+
+// -------------------------------------------------------------------
+
+// UpdateFriendStateNotification
+
+// required .bgs.protocol.friends.v1.Friend changed_friend = 1;
+inline bool UpdateFriendStateNotification::has_changed_friend() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UpdateFriendStateNotification::set_has_changed_friend() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UpdateFriendStateNotification::clear_has_changed_friend() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UpdateFriendStateNotification::clear_changed_friend() {
+  if (changed_friend_ != NULL) changed_friend_->::bgs::protocol::friends::v1::Friend::Clear();
+  clear_has_changed_friend();
+}
+inline const ::bgs::protocol::friends::v1::Friend& UpdateFriendStateNotification::changed_friend() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateNotification.changed_friend)
+  return changed_friend_ != NULL ? *changed_friend_ : *default_instance_->changed_friend_;
+}
+inline ::bgs::protocol::friends::v1::Friend* UpdateFriendStateNotification::mutable_changed_friend() {
+  set_has_changed_friend();
+  if (changed_friend_ == NULL) changed_friend_ = new ::bgs::protocol::friends::v1::Friend;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UpdateFriendStateNotification.changed_friend)
+  return changed_friend_;
+}
+inline ::bgs::protocol::friends::v1::Friend* UpdateFriendStateNotification::release_changed_friend() {
+  clear_has_changed_friend();
+  ::bgs::protocol::friends::v1::Friend* temp = changed_friend_;
+  changed_friend_ = NULL;
+  return temp;
+}
+inline void UpdateFriendStateNotification::set_allocated_changed_friend(::bgs::protocol::friends::v1::Friend* changed_friend) {
+  delete changed_friend_;
+  changed_friend_ = changed_friend;
+  if (changed_friend) {
+    set_has_changed_friend();
+  } else {
+    clear_has_changed_friend();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UpdateFriendStateNotification.changed_friend)
+}
+
+// optional .bgs.protocol.EntityId game_account_id = 2;
+inline bool UpdateFriendStateNotification::has_game_account_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UpdateFriendStateNotification::set_has_game_account_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UpdateFriendStateNotification::clear_has_game_account_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UpdateFriendStateNotification::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& UpdateFriendStateNotification::game_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateNotification.game_account_id)
+  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateFriendStateNotification::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.friends.v1.UpdateFriendStateNotification.game_account_id)
+  return game_account_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateFriendStateNotification::release_game_account_id() {
+  clear_has_game_account_id();
+  ::bgs::protocol::EntityId* temp = game_account_id_;
+  game_account_id_ = NULL;
+  return temp;
+}
+inline void UpdateFriendStateNotification::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.friends.v1.UpdateFriendStateNotification.game_account_id)
+}
+
+// optional .bgs.protocol.ProcessId peer = 4;
+inline bool UpdateFriendStateNotification::has_peer() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void UpdateFriendStateNotification::set_has_peer() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void UpdateFriendStateNotification::clear_has_peer() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void UpdateFriendStateNotification::clear_peer() {
+  if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear();
+  clear_has_peer();
+}
+inline const ::bgs::protocol::ProcessId& UpdateFriendStateNotification::peer() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateNotification.peer)
+  return peer_ != NULL ? *peer_ : *default_instance_->peer_;
+}
+inline ::bgs::protocol::ProcessId* UpdateFriendStateNotification::mutable_peer() {
+  set_has_peer();
+  if (peer_ == NULL) peer_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UpdateFriendStateNotification.peer)
+  return peer_;
+}
+inline ::bgs::protocol::ProcessId* UpdateFriendStateNotification::release_peer() {
+  clear_has_peer();
+  ::bgs::protocol::ProcessId* temp = peer_;
+  peer_ = NULL;
+  return temp;
+}
+inline void UpdateFriendStateNotification::set_allocated_peer(::bgs::protocol::ProcessId* peer) {
+  delete peer_;
+  peer_ = peer;
+  if (peer) {
+    set_has_peer();
+  } else {
+    clear_has_peer();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.UpdateFriendStateNotification.peer)
+}
+
+// optional .bgs.protocol.EntityId account_id = 5;
+inline bool UpdateFriendStateNotification::has_account_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void UpdateFriendStateNotification::set_has_account_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void UpdateFriendStateNotification::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void UpdateFriendStateNotification::clear_account_id() {
+  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_account_id();
+}
+inline const ::bgs::protocol::EntityId& UpdateFriendStateNotification::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.UpdateFriendStateNotification.account_id)
+  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateFriendStateNotification::mutable_account_id() {
+  set_has_account_id();
+  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.UpdateFriendStateNotification.account_id)
+  return account_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateFriendStateNotification::release_account_id() {
+  clear_has_account_id();
+  ::bgs::protocol::EntityId* temp = account_id_;
+  account_id_ = NULL;
+  return temp;
+}
+inline void UpdateFriendStateNotification::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.friends.v1.UpdateFriendStateNotification.account_id)
+}
+
+// -------------------------------------------------------------------
+
+// InvitationNotification
+
+// required .bgs.protocol.Invitation invitation = 1;
+inline bool InvitationNotification::has_invitation() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void InvitationNotification::set_has_invitation() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void InvitationNotification::clear_has_invitation() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void InvitationNotification::clear_invitation() {
+  if (invitation_ != NULL) invitation_->::bgs::protocol::Invitation::Clear();
+  clear_has_invitation();
+}
+inline const ::bgs::protocol::Invitation& InvitationNotification::invitation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.InvitationNotification.invitation)
+  return invitation_ != NULL ? *invitation_ : *default_instance_->invitation_;
+}
+inline ::bgs::protocol::Invitation* InvitationNotification::mutable_invitation() {
+  set_has_invitation();
+  if (invitation_ == NULL) invitation_ = new ::bgs::protocol::Invitation;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.InvitationNotification.invitation)
+  return invitation_;
+}
+inline ::bgs::protocol::Invitation* InvitationNotification::release_invitation() {
+  clear_has_invitation();
+  ::bgs::protocol::Invitation* temp = invitation_;
+  invitation_ = NULL;
+  return temp;
+}
+inline void InvitationNotification::set_allocated_invitation(::bgs::protocol::Invitation* invitation) {
+  delete invitation_;
+  invitation_ = invitation;
+  if (invitation) {
+    set_has_invitation();
+  } else {
+    clear_has_invitation();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.InvitationNotification.invitation)
+}
+
+// optional .bgs.protocol.EntityId game_account_id = 2;
+inline bool InvitationNotification::has_game_account_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void InvitationNotification::set_has_game_account_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void InvitationNotification::clear_has_game_account_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void InvitationNotification::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& InvitationNotification::game_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.InvitationNotification.game_account_id)
+  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
+}
+inline ::bgs::protocol::EntityId* InvitationNotification::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.friends.v1.InvitationNotification.game_account_id)
+  return game_account_id_;
+}
+inline ::bgs::protocol::EntityId* InvitationNotification::release_game_account_id() {
+  clear_has_game_account_id();
+  ::bgs::protocol::EntityId* temp = game_account_id_;
+  game_account_id_ = NULL;
+  return temp;
+}
+inline void InvitationNotification::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.friends.v1.InvitationNotification.game_account_id)
+}
+
+// optional uint32 reason = 3 [default = 0];
+inline bool InvitationNotification::has_reason() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void InvitationNotification::set_has_reason() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void InvitationNotification::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void InvitationNotification::clear_reason() {
+  reason_ = 0u;
+  clear_has_reason();
+}
+inline ::google::protobuf::uint32 InvitationNotification::reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.InvitationNotification.reason)
+  return reason_;
+}
+inline void InvitationNotification::set_reason(::google::protobuf::uint32 value) {
+  set_has_reason();
+  reason_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.InvitationNotification.reason)
+}
+
+// optional .bgs.protocol.ProcessId peer = 4;
+inline bool InvitationNotification::has_peer() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void InvitationNotification::set_has_peer() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void InvitationNotification::clear_has_peer() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void InvitationNotification::clear_peer() {
+  if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear();
+  clear_has_peer();
+}
+inline const ::bgs::protocol::ProcessId& InvitationNotification::peer() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.InvitationNotification.peer)
+  return peer_ != NULL ? *peer_ : *default_instance_->peer_;
+}
+inline ::bgs::protocol::ProcessId* InvitationNotification::mutable_peer() {
+  set_has_peer();
+  if (peer_ == NULL) peer_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.InvitationNotification.peer)
+  return peer_;
+}
+inline ::bgs::protocol::ProcessId* InvitationNotification::release_peer() {
+  clear_has_peer();
+  ::bgs::protocol::ProcessId* temp = peer_;
+  peer_ = NULL;
+  return temp;
+}
+inline void InvitationNotification::set_allocated_peer(::bgs::protocol::ProcessId* peer) {
+  delete peer_;
+  peer_ = peer;
+  if (peer) {
+    set_has_peer();
+  } else {
+    clear_has_peer();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.InvitationNotification.peer)
+}
+
+// optional .bgs.protocol.EntityId account_id = 5;
+inline bool InvitationNotification::has_account_id() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void InvitationNotification::set_has_account_id() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void InvitationNotification::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void InvitationNotification::clear_account_id() {
+  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_account_id();
+}
+inline const ::bgs::protocol::EntityId& InvitationNotification::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.InvitationNotification.account_id)
+  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
+}
+inline ::bgs::protocol::EntityId* InvitationNotification::mutable_account_id() {
+  set_has_account_id();
+  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.InvitationNotification.account_id)
+  return account_id_;
+}
+inline ::bgs::protocol::EntityId* InvitationNotification::release_account_id() {
+  clear_has_account_id();
+  ::bgs::protocol::EntityId* temp = account_id_;
+  account_id_ = NULL;
+  return temp;
+}
+inline void InvitationNotification::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.friends.v1.InvitationNotification.account_id)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace friends
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_friends_5fservice_2eproto__INCLUDED
diff --git a/src/server/proto/Client/friends_types.pb.cc b/src/server/proto/Client/friends_types.pb.cc
new file mode 100644
index 00000000000..8017012c08d
--- /dev/null
+++ b/src/server/proto/Client/friends_types.pb.cc
@@ -0,0 +1,1654 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: friends_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "friends_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace friends {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* Friend_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Friend_reflection_ = NULL;
+const ::google::protobuf::Descriptor* FriendInvitation_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  FriendInvitation_reflection_ = NULL;
+const ::google::protobuf::Descriptor* FriendInvitationParams_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  FriendInvitationParams_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_friends_5ftypes_2eproto() {
+  protobuf_AddDesc_friends_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "friends_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  Friend_descriptor_ = file->message_type(0);
+  static const int Friend_offsets_[7] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, privileges_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, attributes_epoch_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, full_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, battle_tag_),
+  };
+  Friend_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Friend_descriptor_,
+      Friend::default_instance_,
+      Friend_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Friend, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Friend));
+  FriendInvitation_descriptor_ = file->message_type(1);
+  static const int FriendInvitation_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitation, first_received_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitation, role_),
+  };
+  FriendInvitation_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      FriendInvitation_descriptor_,
+      FriendInvitation::default_instance_,
+      FriendInvitation_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitation, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitation, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(FriendInvitation));
+  FriendInvitationParams_descriptor_ = file->message_type(2);
+  static const int FriendInvitationParams_offsets_[7] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, target_email_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, target_battle_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, inviter_battle_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, inviter_full_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, invitee_display_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, previous_role_deprecated_),
+  };
+  FriendInvitationParams_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      FriendInvitationParams_descriptor_,
+      FriendInvitationParams::default_instance_,
+      FriendInvitationParams_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FriendInvitationParams, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(FriendInvitationParams));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_friends_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Friend_descriptor_, &Friend::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    FriendInvitation_descriptor_, &FriendInvitation::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    FriendInvitationParams_descriptor_, &FriendInvitationParams::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_friends_5ftypes_2eproto() {
+  delete Friend::default_instance_;
+  delete Friend_reflection_;
+  delete FriendInvitation::default_instance_;
+  delete FriendInvitation_reflection_;
+  delete FriendInvitationParams::default_instance_;
+  delete FriendInvitationParams_reflection_;
+}
+
+void protobuf_AddDesc_friends_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_invitation_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\023friends_types.proto\022\027bgs.protocol.frie"
+    "nds.v1\032\025attribute_types.proto\032\022entity_ty"
+    "pes.proto\032\026invitation_types.proto\"\312\001\n\006Fr"
+    "iend\022*\n\naccount_id\030\001 \002(\0132\026.bgs.protocol."
+    "EntityId\022*\n\tattribute\030\002 \003(\0132\027.bgs.protoc"
+    "ol.Attribute\022\020\n\004role\030\003 \003(\rB\002\020\001\022\025\n\nprivil"
+    "eges\030\004 \001(\004:\0010\022\030\n\020attributes_epoch\030\005 \001(\004\022"
+    "\021\n\tfull_name\030\006 \001(\t\022\022\n\nbattle_tag\030\007 \001(\t\"\243"
+    "\001\n\020FriendInvitation\022\035\n\016first_received\030\001 "
+    "\001(\010:\005false\022\020\n\004role\030\002 \003(\rB\002\020\0012^\n\021friend_i"
+    "nvitation\022\030.bgs.protocol.Invitation\030g \001("
+    "\0132).bgs.protocol.friends.v1.FriendInvita"
+    "tion\"\300\002\n\026FriendInvitationParams\022\024\n\014targe"
+    "t_email\030\001 \001(\t\022\031\n\021target_battle_tag\030\002 \001(\t"
+    "\022\032\n\022inviter_battle_tag\030\003 \001(\t\022\031\n\021inviter_"
+    "full_name\030\004 \001(\t\022\034\n\024invitee_display_name\030"
+    "\005 \001(\t\022\020\n\004role\030\006 \003(\rB\002\020\001\022&\n\030previous_role"
+    "_deprecated\030\007 \003(\rB\004\020\001\030\0012f\n\rfriend_params"
+    "\022\036.bgs.protocol.InvitationParams\030g \001(\0132/"
+    ".bgs.protocol.friends.v1.FriendInvitatio"
+    "nParamsB/\n\030bnet.protocol.friends.v1B\021Fri"
+    "endsTypesProtoH\001", 856);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "friends_types.proto", &protobuf_RegisterTypes);
+  Friend::default_instance_ = new Friend();
+  FriendInvitation::default_instance_ = new FriendInvitation();
+  FriendInvitationParams::default_instance_ = new FriendInvitationParams();
+  Friend::default_instance_->InitAsDefaultInstance();
+  FriendInvitation::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension(
+    &::bgs::protocol::Invitation::default_instance(),
+    103, 11, false, false,
+    &::bgs::protocol::friends::v1::FriendInvitation::default_instance());
+  FriendInvitationParams::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension(
+    &::bgs::protocol::InvitationParams::default_instance(),
+    103, 11, false, false,
+    &::bgs::protocol::friends::v1::FriendInvitationParams::default_instance());
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_friends_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_friends_5ftypes_2eproto {
+  StaticDescriptorInitializer_friends_5ftypes_2eproto() {
+    protobuf_AddDesc_friends_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_friends_5ftypes_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Friend::kAccountIdFieldNumber;
+const int Friend::kAttributeFieldNumber;
+const int Friend::kRoleFieldNumber;
+const int Friend::kPrivilegesFieldNumber;
+const int Friend::kAttributesEpochFieldNumber;
+const int Friend::kFullNameFieldNumber;
+const int Friend::kBattleTagFieldNumber;
+#endif  // !_MSC_VER
+
+Friend::Friend()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.Friend)
+}
+
+void Friend::InitAsDefaultInstance() {
+  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+Friend::Friend(const Friend& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.Friend)
+}
+
+void Friend::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  account_id_ = NULL;
+  privileges_ = GOOGLE_ULONGLONG(0);
+  attributes_epoch_ = GOOGLE_ULONGLONG(0);
+  full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Friend::~Friend() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.Friend)
+  SharedDtor();
+}
+
+void Friend::SharedDtor() {
+  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete full_name_;
+  }
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete battle_tag_;
+  }
+  if (this != default_instance_) {
+    delete account_id_;
+  }
+}
+
+void Friend::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Friend::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Friend_descriptor_;
+}
+
+const Friend& Friend::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Friend* Friend::default_instance_ = NULL;
+
+Friend* Friend::New() const {
+  return new Friend;
+}
+
+void Friend::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<Friend*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 121) {
+    ZR_(privileges_, attributes_epoch_);
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_full_name()) {
+      if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        full_name_->clear();
+      }
+    }
+    if (has_battle_tag()) {
+      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        battle_tag_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  attribute_.Clear();
+  role_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Friend::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.Friend)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.EntityId account_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.Attribute attribute = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        if (input->ExpectTag(26)) goto parse_role;
+        break;
+      }
+
+      // repeated uint32 role = 3 [packed = true];
+      case 3: {
+        if (tag == 26) {
+         parse_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_role())));
+        } else if (tag == 24) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 26, input, this->mutable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_privileges;
+        break;
+      }
+
+      // optional uint64 privileges = 4 [default = 0];
+      case 4: {
+        if (tag == 32) {
+         parse_privileges:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &privileges_)));
+          set_has_privileges();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_attributes_epoch;
+        break;
+      }
+
+      // optional uint64 attributes_epoch = 5;
+      case 5: {
+        if (tag == 40) {
+         parse_attributes_epoch:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &attributes_epoch_)));
+          set_has_attributes_epoch();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_full_name;
+        break;
+      }
+
+      // optional string full_name = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_full_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_full_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->full_name().data(), this->full_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "full_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_battle_tag;
+        break;
+      }
+
+      // optional string battle_tag = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_battle_tag:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_battle_tag()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->battle_tag().data(), this->battle_tag().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "battle_tag");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.Friend)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.Friend)
+  return false;
+#undef DO_
+}
+
+void Friend::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.Friend)
+  // required .bgs.protocol.EntityId account_id = 1;
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->account_id(), output);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->attribute(i), output);
+  }
+
+  // repeated uint32 role = 3 [packed = true];
+  if (this->role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->role(i), output);
+  }
+
+  // optional uint64 privileges = 4 [default = 0];
+  if (has_privileges()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->privileges(), output);
+  }
+
+  // optional uint64 attributes_epoch = 5;
+  if (has_attributes_epoch()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->attributes_epoch(), output);
+  }
+
+  // optional string full_name = 6;
+  if (has_full_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->full_name().data(), this->full_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "full_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      6, this->full_name(), output);
+  }
+
+  // optional string battle_tag = 7;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      7, this->battle_tag(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.Friend)
+}
+
+::google::protobuf::uint8* Friend::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.Friend)
+  // required .bgs.protocol.EntityId account_id = 1;
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->account_id(), target);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->attribute(i), target);
+  }
+
+  // repeated uint32 role = 3 [packed = true];
+  if (this->role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      3,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->role(i), target);
+  }
+
+  // optional uint64 privileges = 4 [default = 0];
+  if (has_privileges()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->privileges(), target);
+  }
+
+  // optional uint64 attributes_epoch = 5;
+  if (has_attributes_epoch()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->attributes_epoch(), target);
+  }
+
+  // optional string full_name = 6;
+  if (has_full_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->full_name().data(), this->full_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "full_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        6, this->full_name(), target);
+  }
+
+  // optional string battle_tag = 7;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        7, this->battle_tag(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.Friend)
+  return target;
+}
+
+int Friend::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.EntityId account_id = 1;
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+    // optional uint64 privileges = 4 [default = 0];
+    if (has_privileges()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->privileges());
+    }
+
+    // optional uint64 attributes_epoch = 5;
+    if (has_attributes_epoch()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->attributes_epoch());
+    }
+
+    // optional string full_name = 6;
+    if (has_full_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->full_name());
+    }
+
+    // optional string battle_tag = 7;
+    if (has_battle_tag()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->battle_tag());
+    }
+
+  }
+  // repeated .bgs.protocol.Attribute attribute = 2;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  // repeated uint32 role = 3 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Friend::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Friend* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Friend*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Friend::MergeFrom(const Friend& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  role_.MergeFrom(from.role_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
+    }
+    if (from.has_privileges()) {
+      set_privileges(from.privileges());
+    }
+    if (from.has_attributes_epoch()) {
+      set_attributes_epoch(from.attributes_epoch());
+    }
+    if (from.has_full_name()) {
+      set_full_name(from.full_name());
+    }
+    if (from.has_battle_tag()) {
+      set_battle_tag(from.battle_tag());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Friend::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Friend::CopyFrom(const Friend& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Friend::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
+  return true;
+}
+
+void Friend::Swap(Friend* other) {
+  if (other != this) {
+    std::swap(account_id_, other->account_id_);
+    attribute_.Swap(&other->attribute_);
+    role_.Swap(&other->role_);
+    std::swap(privileges_, other->privileges_);
+    std::swap(attributes_epoch_, other->attributes_epoch_);
+    std::swap(full_name_, other->full_name_);
+    std::swap(battle_tag_, other->battle_tag_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Friend::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Friend_descriptor_;
+  metadata.reflection = Friend_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int FriendInvitation::kFirstReceivedFieldNumber;
+const int FriendInvitation::kRoleFieldNumber;
+#endif  // !_MSC_VER
+
+#ifndef _MSC_VER
+const int FriendInvitation::kFriendInvitationFieldNumber;
+#endif
+::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::Invitation,
+    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::friends::v1::FriendInvitation >, 11, false >
+  FriendInvitation::friend_invitation(kFriendInvitationFieldNumber, ::bgs::protocol::friends::v1::FriendInvitation::default_instance());
+FriendInvitation::FriendInvitation()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.FriendInvitation)
+}
+
+void FriendInvitation::InitAsDefaultInstance() {
+}
+
+FriendInvitation::FriendInvitation(const FriendInvitation& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.FriendInvitation)
+}
+
+void FriendInvitation::SharedCtor() {
+  _cached_size_ = 0;
+  first_received_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+FriendInvitation::~FriendInvitation() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.FriendInvitation)
+  SharedDtor();
+}
+
+void FriendInvitation::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void FriendInvitation::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* FriendInvitation::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return FriendInvitation_descriptor_;
+}
+
+const FriendInvitation& FriendInvitation::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+FriendInvitation* FriendInvitation::default_instance_ = NULL;
+
+FriendInvitation* FriendInvitation::New() const {
+  return new FriendInvitation;
+}
+
+void FriendInvitation::Clear() {
+  first_received_ = false;
+  role_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool FriendInvitation::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.FriendInvitation)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional bool first_received = 1 [default = false];
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &first_received_)));
+          set_has_first_received();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_role;
+        break;
+      }
+
+      // repeated uint32 role = 2 [packed = true];
+      case 2: {
+        if (tag == 18) {
+         parse_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_role())));
+        } else if (tag == 16) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 18, input, this->mutable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.FriendInvitation)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.FriendInvitation)
+  return false;
+#undef DO_
+}
+
+void FriendInvitation::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.FriendInvitation)
+  // optional bool first_received = 1 [default = false];
+  if (has_first_received()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->first_received(), output);
+  }
+
+  // repeated uint32 role = 2 [packed = true];
+  if (this->role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(2, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->role(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.FriendInvitation)
+}
+
+::google::protobuf::uint8* FriendInvitation::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.FriendInvitation)
+  // optional bool first_received = 1 [default = false];
+  if (has_first_received()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(1, this->first_received(), target);
+  }
+
+  // repeated uint32 role = 2 [packed = true];
+  if (this->role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      2,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->role(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.FriendInvitation)
+  return target;
+}
+
+int FriendInvitation::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional bool first_received = 1 [default = false];
+    if (has_first_received()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated uint32 role = 2 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FriendInvitation::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const FriendInvitation* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const FriendInvitation*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void FriendInvitation::MergeFrom(const FriendInvitation& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  role_.MergeFrom(from.role_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_first_received()) {
+      set_first_received(from.first_received());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void FriendInvitation::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void FriendInvitation::CopyFrom(const FriendInvitation& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FriendInvitation::IsInitialized() const {
+
+  return true;
+}
+
+void FriendInvitation::Swap(FriendInvitation* other) {
+  if (other != this) {
+    std::swap(first_received_, other->first_received_);
+    role_.Swap(&other->role_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata FriendInvitation::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = FriendInvitation_descriptor_;
+  metadata.reflection = FriendInvitation_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int FriendInvitationParams::kTargetEmailFieldNumber;
+const int FriendInvitationParams::kTargetBattleTagFieldNumber;
+const int FriendInvitationParams::kInviterBattleTagFieldNumber;
+const int FriendInvitationParams::kInviterFullNameFieldNumber;
+const int FriendInvitationParams::kInviteeDisplayNameFieldNumber;
+const int FriendInvitationParams::kRoleFieldNumber;
+const int FriendInvitationParams::kPreviousRoleDeprecatedFieldNumber;
+#endif  // !_MSC_VER
+
+#ifndef _MSC_VER
+const int FriendInvitationParams::kFriendParamsFieldNumber;
+#endif
+::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::InvitationParams,
+    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::friends::v1::FriendInvitationParams >, 11, false >
+  FriendInvitationParams::friend_params(kFriendParamsFieldNumber, ::bgs::protocol::friends::v1::FriendInvitationParams::default_instance());
+FriendInvitationParams::FriendInvitationParams()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.friends.v1.FriendInvitationParams)
+}
+
+void FriendInvitationParams::InitAsDefaultInstance() {
+}
+
+FriendInvitationParams::FriendInvitationParams(const FriendInvitationParams& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.friends.v1.FriendInvitationParams)
+}
+
+void FriendInvitationParams::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  target_email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  target_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  inviter_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  inviter_full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  invitee_display_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+FriendInvitationParams::~FriendInvitationParams() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.friends.v1.FriendInvitationParams)
+  SharedDtor();
+}
+
+void FriendInvitationParams::SharedDtor() {
+  if (target_email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete target_email_;
+  }
+  if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete target_battle_tag_;
+  }
+  if (inviter_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete inviter_battle_tag_;
+  }
+  if (inviter_full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete inviter_full_name_;
+  }
+  if (invitee_display_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete invitee_display_name_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void FriendInvitationParams::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* FriendInvitationParams::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return FriendInvitationParams_descriptor_;
+}
+
+const FriendInvitationParams& FriendInvitationParams::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_friends_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+FriendInvitationParams* FriendInvitationParams::default_instance_ = NULL;
+
+FriendInvitationParams* FriendInvitationParams::New() const {
+  return new FriendInvitationParams;
+}
+
+void FriendInvitationParams::Clear() {
+  if (_has_bits_[0 / 32] & 31) {
+    if (has_target_email()) {
+      if (target_email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        target_email_->clear();
+      }
+    }
+    if (has_target_battle_tag()) {
+      if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        target_battle_tag_->clear();
+      }
+    }
+    if (has_inviter_battle_tag()) {
+      if (inviter_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        inviter_battle_tag_->clear();
+      }
+    }
+    if (has_inviter_full_name()) {
+      if (inviter_full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        inviter_full_name_->clear();
+      }
+    }
+    if (has_invitee_display_name()) {
+      if (invitee_display_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        invitee_display_name_->clear();
+      }
+    }
+  }
+  role_.Clear();
+  previous_role_deprecated_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool FriendInvitationParams::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.friends.v1.FriendInvitationParams)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string target_email = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_target_email()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->target_email().data(), this->target_email().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "target_email");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_target_battle_tag;
+        break;
+      }
+
+      // optional string target_battle_tag = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_target_battle_tag:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_target_battle_tag()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->target_battle_tag().data(), this->target_battle_tag().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "target_battle_tag");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_inviter_battle_tag;
+        break;
+      }
+
+      // optional string inviter_battle_tag = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_inviter_battle_tag:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_inviter_battle_tag()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->inviter_battle_tag().data(), this->inviter_battle_tag().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "inviter_battle_tag");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_inviter_full_name;
+        break;
+      }
+
+      // optional string inviter_full_name = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_inviter_full_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_inviter_full_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->inviter_full_name().data(), this->inviter_full_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "inviter_full_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_invitee_display_name;
+        break;
+      }
+
+      // optional string invitee_display_name = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_invitee_display_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_invitee_display_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->invitee_display_name().data(), this->invitee_display_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "invitee_display_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_role;
+        break;
+      }
+
+      // repeated uint32 role = 6 [packed = true];
+      case 6: {
+        if (tag == 50) {
+         parse_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_role())));
+        } else if (tag == 48) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 50, input, this->mutable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_previous_role_deprecated;
+        break;
+      }
+
+      // repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true];
+      case 7: {
+        if (tag == 58) {
+         parse_previous_role_deprecated:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_previous_role_deprecated())));
+        } else if (tag == 56) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 58, input, this->mutable_previous_role_deprecated())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.friends.v1.FriendInvitationParams)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.friends.v1.FriendInvitationParams)
+  return false;
+#undef DO_
+}
+
+void FriendInvitationParams::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.friends.v1.FriendInvitationParams)
+  // optional string target_email = 1;
+  if (has_target_email()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->target_email().data(), this->target_email().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "target_email");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->target_email(), output);
+  }
+
+  // optional string target_battle_tag = 2;
+  if (has_target_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->target_battle_tag().data(), this->target_battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "target_battle_tag");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->target_battle_tag(), output);
+  }
+
+  // optional string inviter_battle_tag = 3;
+  if (has_inviter_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->inviter_battle_tag().data(), this->inviter_battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "inviter_battle_tag");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->inviter_battle_tag(), output);
+  }
+
+  // optional string inviter_full_name = 4;
+  if (has_inviter_full_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->inviter_full_name().data(), this->inviter_full_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "inviter_full_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->inviter_full_name(), output);
+  }
+
+  // optional string invitee_display_name = 5;
+  if (has_invitee_display_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->invitee_display_name().data(), this->invitee_display_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "invitee_display_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      5, this->invitee_display_name(), output);
+  }
+
+  // repeated uint32 role = 6 [packed = true];
+  if (this->role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(6, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->role(i), output);
+  }
+
+  // repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true];
+  if (this->previous_role_deprecated_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(7, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_previous_role_deprecated_cached_byte_size_);
+  }
+  for (int i = 0; i < this->previous_role_deprecated_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->previous_role_deprecated(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.friends.v1.FriendInvitationParams)
+}
+
+::google::protobuf::uint8* FriendInvitationParams::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.friends.v1.FriendInvitationParams)
+  // optional string target_email = 1;
+  if (has_target_email()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->target_email().data(), this->target_email().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "target_email");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->target_email(), target);
+  }
+
+  // optional string target_battle_tag = 2;
+  if (has_target_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->target_battle_tag().data(), this->target_battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "target_battle_tag");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->target_battle_tag(), target);
+  }
+
+  // optional string inviter_battle_tag = 3;
+  if (has_inviter_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->inviter_battle_tag().data(), this->inviter_battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "inviter_battle_tag");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->inviter_battle_tag(), target);
+  }
+
+  // optional string inviter_full_name = 4;
+  if (has_inviter_full_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->inviter_full_name().data(), this->inviter_full_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "inviter_full_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->inviter_full_name(), target);
+  }
+
+  // optional string invitee_display_name = 5;
+  if (has_invitee_display_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->invitee_display_name().data(), this->invitee_display_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "invitee_display_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->invitee_display_name(), target);
+  }
+
+  // repeated uint32 role = 6 [packed = true];
+  if (this->role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      6,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->role(i), target);
+  }
+
+  // repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true];
+  if (this->previous_role_deprecated_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      7,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _previous_role_deprecated_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->previous_role_deprecated_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->previous_role_deprecated(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.friends.v1.FriendInvitationParams)
+  return target;
+}
+
+int FriendInvitationParams::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string target_email = 1;
+    if (has_target_email()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->target_email());
+    }
+
+    // optional string target_battle_tag = 2;
+    if (has_target_battle_tag()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->target_battle_tag());
+    }
+
+    // optional string inviter_battle_tag = 3;
+    if (has_inviter_battle_tag()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->inviter_battle_tag());
+    }
+
+    // optional string inviter_full_name = 4;
+    if (has_inviter_full_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->inviter_full_name());
+    }
+
+    // optional string invitee_display_name = 5;
+    if (has_invitee_display_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->invitee_display_name());
+    }
+
+  }
+  // repeated uint32 role = 6 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->previous_role_deprecated_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->previous_role_deprecated(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _previous_role_deprecated_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FriendInvitationParams::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const FriendInvitationParams* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const FriendInvitationParams*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void FriendInvitationParams::MergeFrom(const FriendInvitationParams& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  role_.MergeFrom(from.role_);
+  previous_role_deprecated_.MergeFrom(from.previous_role_deprecated_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_target_email()) {
+      set_target_email(from.target_email());
+    }
+    if (from.has_target_battle_tag()) {
+      set_target_battle_tag(from.target_battle_tag());
+    }
+    if (from.has_inviter_battle_tag()) {
+      set_inviter_battle_tag(from.inviter_battle_tag());
+    }
+    if (from.has_inviter_full_name()) {
+      set_inviter_full_name(from.inviter_full_name());
+    }
+    if (from.has_invitee_display_name()) {
+      set_invitee_display_name(from.invitee_display_name());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void FriendInvitationParams::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void FriendInvitationParams::CopyFrom(const FriendInvitationParams& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FriendInvitationParams::IsInitialized() const {
+
+  return true;
+}
+
+void FriendInvitationParams::Swap(FriendInvitationParams* other) {
+  if (other != this) {
+    std::swap(target_email_, other->target_email_);
+    std::swap(target_battle_tag_, other->target_battle_tag_);
+    std::swap(inviter_battle_tag_, other->inviter_battle_tag_);
+    std::swap(inviter_full_name_, other->inviter_full_name_);
+    std::swap(invitee_display_name_, other->invitee_display_name_);
+    role_.Swap(&other->role_);
+    previous_role_deprecated_.Swap(&other->previous_role_deprecated_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata FriendInvitationParams::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = FriendInvitationParams_descriptor_;
+  metadata.reflection = FriendInvitationParams_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace friends
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/friends_types.pb.h b/src/server/proto/Client/friends_types.pb.h
new file mode 100644
index 00000000000..644d0a5b8db
--- /dev/null
+++ b/src/server/proto/Client/friends_types.pb.h
@@ -0,0 +1,1310 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: friends_types.proto
+
+#ifndef PROTOBUF_friends_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_friends_5ftypes_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 "attribute_types.pb.h"
+#include "entity_types.pb.h"
+#include "invitation_types.pb.h"
+#include "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace friends {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_friends_5ftypes_2eproto();
+void protobuf_AssignDesc_friends_5ftypes_2eproto();
+void protobuf_ShutdownFile_friends_5ftypes_2eproto();
+
+class Friend;
+class FriendInvitation;
+class FriendInvitationParams;
+
+// ===================================================================
+
+class TC_SHARED_API Friend : public ::google::protobuf::Message {
+ public:
+  Friend();
+  virtual ~Friend();
+
+  Friend(const Friend& from);
+
+  inline Friend& operator=(const Friend& 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 Friend& default_instance();
+
+  void Swap(Friend* other);
+
+  // implements Message ----------------------------------------------
+
+  Friend* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Friend& from);
+  void MergeFrom(const Friend& 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 account_id = 1;
+  inline bool has_account_id() const;
+  inline void clear_account_id();
+  static const int kAccountIdFieldNumber = 1;
+  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.Attribute attribute = 2;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 2;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
+  // repeated uint32 role = 3 [packed = true];
+  inline int role_size() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 3;
+  inline ::google::protobuf::uint32 role(int index) const;
+  inline void set_role(int index, ::google::protobuf::uint32 value);
+  inline void add_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_role();
+
+  // optional uint64 privileges = 4 [default = 0];
+  inline bool has_privileges() const;
+  inline void clear_privileges();
+  static const int kPrivilegesFieldNumber = 4;
+  inline ::google::protobuf::uint64 privileges() const;
+  inline void set_privileges(::google::protobuf::uint64 value);
+
+  // optional uint64 attributes_epoch = 5;
+  inline bool has_attributes_epoch() const;
+  inline void clear_attributes_epoch();
+  static const int kAttributesEpochFieldNumber = 5;
+  inline ::google::protobuf::uint64 attributes_epoch() const;
+  inline void set_attributes_epoch(::google::protobuf::uint64 value);
+
+  // optional string full_name = 6;
+  inline bool has_full_name() const;
+  inline void clear_full_name();
+  static const int kFullNameFieldNumber = 6;
+  inline const ::std::string& full_name() const;
+  inline void set_full_name(const ::std::string& value);
+  inline void set_full_name(const char* value);
+  inline void set_full_name(const char* value, size_t size);
+  inline ::std::string* mutable_full_name();
+  inline ::std::string* release_full_name();
+  inline void set_allocated_full_name(::std::string* full_name);
+
+  // 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);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.Friend)
+ private:
+  inline void set_has_account_id();
+  inline void clear_has_account_id();
+  inline void set_has_privileges();
+  inline void clear_has_privileges();
+  inline void set_has_attributes_epoch();
+  inline void clear_has_attributes_epoch();
+  inline void set_has_full_name();
+  inline void clear_has_full_name();
+  inline void set_has_battle_tag();
+  inline void clear_has_battle_tag();
+
+  ::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::Attribute > attribute_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
+  mutable int _role_cached_byte_size_;
+  ::google::protobuf::uint64 privileges_;
+  ::google::protobuf::uint64 attributes_epoch_;
+  ::std::string* full_name_;
+  ::std::string* battle_tag_;
+  friend void TC_SHARED_API protobuf_AddDesc_friends_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_friends_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_friends_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Friend* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API FriendInvitation : public ::google::protobuf::Message {
+ public:
+  FriendInvitation();
+  virtual ~FriendInvitation();
+
+  FriendInvitation(const FriendInvitation& from);
+
+  inline FriendInvitation& operator=(const FriendInvitation& 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 FriendInvitation& default_instance();
+
+  void Swap(FriendInvitation* other);
+
+  // implements Message ----------------------------------------------
+
+  FriendInvitation* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const FriendInvitation& from);
+  void MergeFrom(const FriendInvitation& 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 bool first_received = 1 [default = false];
+  inline bool has_first_received() const;
+  inline void clear_first_received();
+  static const int kFirstReceivedFieldNumber = 1;
+  inline bool first_received() const;
+  inline void set_first_received(bool value);
+
+  // repeated uint32 role = 2 [packed = true];
+  inline int role_size() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 2;
+  inline ::google::protobuf::uint32 role(int index) const;
+  inline void set_role(int index, ::google::protobuf::uint32 value);
+  inline void add_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_role();
+
+  static const int kFriendInvitationFieldNumber = 103;
+  static ::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::Invitation,
+      ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::friends::v1::FriendInvitation >, 11, false >
+    friend_invitation;
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.FriendInvitation)
+ private:
+  inline void set_has_first_received();
+  inline void clear_has_first_received();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
+  mutable int _role_cached_byte_size_;
+  bool first_received_;
+  friend void TC_SHARED_API protobuf_AddDesc_friends_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_friends_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_friends_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static FriendInvitation* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API FriendInvitationParams : public ::google::protobuf::Message {
+ public:
+  FriendInvitationParams();
+  virtual ~FriendInvitationParams();
+
+  FriendInvitationParams(const FriendInvitationParams& from);
+
+  inline FriendInvitationParams& operator=(const FriendInvitationParams& 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 FriendInvitationParams& default_instance();
+
+  void Swap(FriendInvitationParams* other);
+
+  // implements Message ----------------------------------------------
+
+  FriendInvitationParams* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const FriendInvitationParams& from);
+  void MergeFrom(const FriendInvitationParams& 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 target_email = 1;
+  inline bool has_target_email() const;
+  inline void clear_target_email();
+  static const int kTargetEmailFieldNumber = 1;
+  inline const ::std::string& target_email() const;
+  inline void set_target_email(const ::std::string& value);
+  inline void set_target_email(const char* value);
+  inline void set_target_email(const char* value, size_t size);
+  inline ::std::string* mutable_target_email();
+  inline ::std::string* release_target_email();
+  inline void set_allocated_target_email(::std::string* target_email);
+
+  // optional string target_battle_tag = 2;
+  inline bool has_target_battle_tag() const;
+  inline void clear_target_battle_tag();
+  static const int kTargetBattleTagFieldNumber = 2;
+  inline const ::std::string& target_battle_tag() const;
+  inline void set_target_battle_tag(const ::std::string& value);
+  inline void set_target_battle_tag(const char* value);
+  inline void set_target_battle_tag(const char* value, size_t size);
+  inline ::std::string* mutable_target_battle_tag();
+  inline ::std::string* release_target_battle_tag();
+  inline void set_allocated_target_battle_tag(::std::string* target_battle_tag);
+
+  // optional string inviter_battle_tag = 3;
+  inline bool has_inviter_battle_tag() const;
+  inline void clear_inviter_battle_tag();
+  static const int kInviterBattleTagFieldNumber = 3;
+  inline const ::std::string& inviter_battle_tag() const;
+  inline void set_inviter_battle_tag(const ::std::string& value);
+  inline void set_inviter_battle_tag(const char* value);
+  inline void set_inviter_battle_tag(const char* value, size_t size);
+  inline ::std::string* mutable_inviter_battle_tag();
+  inline ::std::string* release_inviter_battle_tag();
+  inline void set_allocated_inviter_battle_tag(::std::string* inviter_battle_tag);
+
+  // optional string inviter_full_name = 4;
+  inline bool has_inviter_full_name() const;
+  inline void clear_inviter_full_name();
+  static const int kInviterFullNameFieldNumber = 4;
+  inline const ::std::string& inviter_full_name() const;
+  inline void set_inviter_full_name(const ::std::string& value);
+  inline void set_inviter_full_name(const char* value);
+  inline void set_inviter_full_name(const char* value, size_t size);
+  inline ::std::string* mutable_inviter_full_name();
+  inline ::std::string* release_inviter_full_name();
+  inline void set_allocated_inviter_full_name(::std::string* inviter_full_name);
+
+  // optional string invitee_display_name = 5;
+  inline bool has_invitee_display_name() const;
+  inline void clear_invitee_display_name();
+  static const int kInviteeDisplayNameFieldNumber = 5;
+  inline const ::std::string& invitee_display_name() const;
+  inline void set_invitee_display_name(const ::std::string& value);
+  inline void set_invitee_display_name(const char* value);
+  inline void set_invitee_display_name(const char* value, size_t size);
+  inline ::std::string* mutable_invitee_display_name();
+  inline ::std::string* release_invitee_display_name();
+  inline void set_allocated_invitee_display_name(::std::string* invitee_display_name);
+
+  // repeated uint32 role = 6 [packed = true];
+  inline int role_size() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 6;
+  inline ::google::protobuf::uint32 role(int index) const;
+  inline void set_role(int index, ::google::protobuf::uint32 value);
+  inline void add_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_role();
+
+  // repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true];
+  inline int previous_role_deprecated_size() const PROTOBUF_DEPRECATED;
+  inline void clear_previous_role_deprecated() PROTOBUF_DEPRECATED;
+  static const int kPreviousRoleDeprecatedFieldNumber = 7;
+  inline ::google::protobuf::uint32 previous_role_deprecated(int index) const PROTOBUF_DEPRECATED;
+  inline void set_previous_role_deprecated(int index, ::google::protobuf::uint32 value) PROTOBUF_DEPRECATED;
+  inline void add_previous_role_deprecated(::google::protobuf::uint32 value) PROTOBUF_DEPRECATED;
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      previous_role_deprecated() const PROTOBUF_DEPRECATED;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_previous_role_deprecated() PROTOBUF_DEPRECATED;
+
+  static const int kFriendParamsFieldNumber = 103;
+  static ::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::InvitationParams,
+      ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::friends::v1::FriendInvitationParams >, 11, false >
+    friend_params;
+  // @@protoc_insertion_point(class_scope:bgs.protocol.friends.v1.FriendInvitationParams)
+ private:
+  inline void set_has_target_email();
+  inline void clear_has_target_email();
+  inline void set_has_target_battle_tag();
+  inline void clear_has_target_battle_tag();
+  inline void set_has_inviter_battle_tag();
+  inline void clear_has_inviter_battle_tag();
+  inline void set_has_inviter_full_name();
+  inline void clear_has_inviter_full_name();
+  inline void set_has_invitee_display_name();
+  inline void clear_has_invitee_display_name();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* target_email_;
+  ::std::string* target_battle_tag_;
+  ::std::string* inviter_battle_tag_;
+  ::std::string* inviter_full_name_;
+  ::std::string* invitee_display_name_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
+  mutable int _role_cached_byte_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > previous_role_deprecated_;
+  mutable int _previous_role_deprecated_cached_byte_size_;
+  friend void TC_SHARED_API protobuf_AddDesc_friends_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_friends_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_friends_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static FriendInvitationParams* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// Friend
+
+// required .bgs.protocol.EntityId account_id = 1;
+inline bool Friend::has_account_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Friend::set_has_account_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Friend::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Friend::clear_account_id() {
+  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_account_id();
+}
+inline const ::bgs::protocol::EntityId& Friend::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.Friend.account_id)
+  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
+}
+inline ::bgs::protocol::EntityId* Friend::mutable_account_id() {
+  set_has_account_id();
+  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.Friend.account_id)
+  return account_id_;
+}
+inline ::bgs::protocol::EntityId* Friend::release_account_id() {
+  clear_has_account_id();
+  ::bgs::protocol::EntityId* temp = account_id_;
+  account_id_ = NULL;
+  return temp;
+}
+inline void Friend::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.friends.v1.Friend.account_id)
+}
+
+// repeated .bgs.protocol.Attribute attribute = 2;
+inline int Friend::attribute_size() const {
+  return attribute_.size();
+}
+inline void Friend::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::Attribute& Friend::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.Friend.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::Attribute* Friend::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.Friend.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* Friend::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.Friend.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+Friend::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.Friend.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+Friend::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.Friend.attribute)
+  return &attribute_;
+}
+
+// repeated uint32 role = 3 [packed = true];
+inline int Friend::role_size() const {
+  return role_.size();
+}
+inline void Friend::clear_role() {
+  role_.Clear();
+}
+inline ::google::protobuf::uint32 Friend::role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.Friend.role)
+  return role_.Get(index);
+}
+inline void Friend::set_role(int index, ::google::protobuf::uint32 value) {
+  role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.Friend.role)
+}
+inline void Friend::add_role(::google::protobuf::uint32 value) {
+  role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.Friend.role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+Friend::role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.Friend.role)
+  return role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+Friend::mutable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.Friend.role)
+  return &role_;
+}
+
+// optional uint64 privileges = 4 [default = 0];
+inline bool Friend::has_privileges() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Friend::set_has_privileges() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Friend::clear_has_privileges() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Friend::clear_privileges() {
+  privileges_ = GOOGLE_ULONGLONG(0);
+  clear_has_privileges();
+}
+inline ::google::protobuf::uint64 Friend::privileges() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.Friend.privileges)
+  return privileges_;
+}
+inline void Friend::set_privileges(::google::protobuf::uint64 value) {
+  set_has_privileges();
+  privileges_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.Friend.privileges)
+}
+
+// optional uint64 attributes_epoch = 5;
+inline bool Friend::has_attributes_epoch() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void Friend::set_has_attributes_epoch() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void Friend::clear_has_attributes_epoch() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void Friend::clear_attributes_epoch() {
+  attributes_epoch_ = GOOGLE_ULONGLONG(0);
+  clear_has_attributes_epoch();
+}
+inline ::google::protobuf::uint64 Friend::attributes_epoch() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.Friend.attributes_epoch)
+  return attributes_epoch_;
+}
+inline void Friend::set_attributes_epoch(::google::protobuf::uint64 value) {
+  set_has_attributes_epoch();
+  attributes_epoch_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.Friend.attributes_epoch)
+}
+
+// optional string full_name = 6;
+inline bool Friend::has_full_name() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void Friend::set_has_full_name() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void Friend::clear_has_full_name() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void Friend::clear_full_name() {
+  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_->clear();
+  }
+  clear_has_full_name();
+}
+inline const ::std::string& Friend::full_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.Friend.full_name)
+  return *full_name_;
+}
+inline void Friend::set_full_name(const ::std::string& value) {
+  set_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_ = new ::std::string;
+  }
+  full_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.Friend.full_name)
+}
+inline void Friend::set_full_name(const char* value) {
+  set_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_ = new ::std::string;
+  }
+  full_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.Friend.full_name)
+}
+inline void Friend::set_full_name(const char* value, size_t size) {
+  set_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_ = new ::std::string;
+  }
+  full_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.Friend.full_name)
+}
+inline ::std::string* Friend::mutable_full_name() {
+  set_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    full_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.Friend.full_name)
+  return full_name_;
+}
+inline ::std::string* Friend::release_full_name() {
+  clear_has_full_name();
+  if (full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = full_name_;
+    full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Friend::set_allocated_full_name(::std::string* full_name) {
+  if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete full_name_;
+  }
+  if (full_name) {
+    set_has_full_name();
+    full_name_ = full_name;
+  } else {
+    clear_has_full_name();
+    full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.Friend.full_name)
+}
+
+// optional string battle_tag = 7;
+inline bool Friend::has_battle_tag() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void Friend::set_has_battle_tag() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void Friend::clear_has_battle_tag() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void Friend::clear_battle_tag() {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_->clear();
+  }
+  clear_has_battle_tag();
+}
+inline const ::std::string& Friend::battle_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.Friend.battle_tag)
+  return *battle_tag_;
+}
+inline void Friend::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.friends.v1.Friend.battle_tag)
+}
+inline void Friend::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.friends.v1.Friend.battle_tag)
+}
+inline void Friend::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.friends.v1.Friend.battle_tag)
+}
+inline ::std::string* Friend::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.friends.v1.Friend.battle_tag)
+  return battle_tag_;
+}
+inline ::std::string* Friend::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 Friend::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.friends.v1.Friend.battle_tag)
+}
+
+// -------------------------------------------------------------------
+
+// FriendInvitation
+
+// optional bool first_received = 1 [default = false];
+inline bool FriendInvitation::has_first_received() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FriendInvitation::set_has_first_received() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FriendInvitation::clear_has_first_received() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FriendInvitation::clear_first_received() {
+  first_received_ = false;
+  clear_has_first_received();
+}
+inline bool FriendInvitation::first_received() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitation.first_received)
+  return first_received_;
+}
+inline void FriendInvitation::set_first_received(bool value) {
+  set_has_first_received();
+  first_received_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitation.first_received)
+}
+
+// repeated uint32 role = 2 [packed = true];
+inline int FriendInvitation::role_size() const {
+  return role_.size();
+}
+inline void FriendInvitation::clear_role() {
+  role_.Clear();
+}
+inline ::google::protobuf::uint32 FriendInvitation::role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitation.role)
+  return role_.Get(index);
+}
+inline void FriendInvitation::set_role(int index, ::google::protobuf::uint32 value) {
+  role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitation.role)
+}
+inline void FriendInvitation::add_role(::google::protobuf::uint32 value) {
+  role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.FriendInvitation.role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+FriendInvitation::role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.FriendInvitation.role)
+  return role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+FriendInvitation::mutable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.FriendInvitation.role)
+  return &role_;
+}
+
+// -------------------------------------------------------------------
+
+// FriendInvitationParams
+
+// optional string target_email = 1;
+inline bool FriendInvitationParams::has_target_email() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FriendInvitationParams::set_has_target_email() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FriendInvitationParams::clear_has_target_email() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FriendInvitationParams::clear_target_email() {
+  if (target_email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_email_->clear();
+  }
+  clear_has_target_email();
+}
+inline const ::std::string& FriendInvitationParams::target_email() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.target_email)
+  return *target_email_;
+}
+inline void FriendInvitationParams::set_target_email(const ::std::string& value) {
+  set_has_target_email();
+  if (target_email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_email_ = new ::std::string;
+  }
+  target_email_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.target_email)
+}
+inline void FriendInvitationParams::set_target_email(const char* value) {
+  set_has_target_email();
+  if (target_email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_email_ = new ::std::string;
+  }
+  target_email_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.FriendInvitationParams.target_email)
+}
+inline void FriendInvitationParams::set_target_email(const char* value, size_t size) {
+  set_has_target_email();
+  if (target_email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_email_ = new ::std::string;
+  }
+  target_email_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.FriendInvitationParams.target_email)
+}
+inline ::std::string* FriendInvitationParams::mutable_target_email() {
+  set_has_target_email();
+  if (target_email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_email_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendInvitationParams.target_email)
+  return target_email_;
+}
+inline ::std::string* FriendInvitationParams::release_target_email() {
+  clear_has_target_email();
+  if (target_email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = target_email_;
+    target_email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void FriendInvitationParams::set_allocated_target_email(::std::string* target_email) {
+  if (target_email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete target_email_;
+  }
+  if (target_email) {
+    set_has_target_email();
+    target_email_ = target_email;
+  } else {
+    clear_has_target_email();
+    target_email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendInvitationParams.target_email)
+}
+
+// optional string target_battle_tag = 2;
+inline bool FriendInvitationParams::has_target_battle_tag() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void FriendInvitationParams::set_has_target_battle_tag() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void FriendInvitationParams::clear_has_target_battle_tag() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void FriendInvitationParams::clear_target_battle_tag() {
+  if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_battle_tag_->clear();
+  }
+  clear_has_target_battle_tag();
+}
+inline const ::std::string& FriendInvitationParams::target_battle_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.target_battle_tag)
+  return *target_battle_tag_;
+}
+inline void FriendInvitationParams::set_target_battle_tag(const ::std::string& value) {
+  set_has_target_battle_tag();
+  if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_battle_tag_ = new ::std::string;
+  }
+  target_battle_tag_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.target_battle_tag)
+}
+inline void FriendInvitationParams::set_target_battle_tag(const char* value) {
+  set_has_target_battle_tag();
+  if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_battle_tag_ = new ::std::string;
+  }
+  target_battle_tag_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.FriendInvitationParams.target_battle_tag)
+}
+inline void FriendInvitationParams::set_target_battle_tag(const char* value, size_t size) {
+  set_has_target_battle_tag();
+  if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_battle_tag_ = new ::std::string;
+  }
+  target_battle_tag_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.FriendInvitationParams.target_battle_tag)
+}
+inline ::std::string* FriendInvitationParams::mutable_target_battle_tag() {
+  set_has_target_battle_tag();
+  if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_battle_tag_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendInvitationParams.target_battle_tag)
+  return target_battle_tag_;
+}
+inline ::std::string* FriendInvitationParams::release_target_battle_tag() {
+  clear_has_target_battle_tag();
+  if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = target_battle_tag_;
+    target_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void FriendInvitationParams::set_allocated_target_battle_tag(::std::string* target_battle_tag) {
+  if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete target_battle_tag_;
+  }
+  if (target_battle_tag) {
+    set_has_target_battle_tag();
+    target_battle_tag_ = target_battle_tag;
+  } else {
+    clear_has_target_battle_tag();
+    target_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendInvitationParams.target_battle_tag)
+}
+
+// optional string inviter_battle_tag = 3;
+inline bool FriendInvitationParams::has_inviter_battle_tag() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void FriendInvitationParams::set_has_inviter_battle_tag() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void FriendInvitationParams::clear_has_inviter_battle_tag() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void FriendInvitationParams::clear_inviter_battle_tag() {
+  if (inviter_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_battle_tag_->clear();
+  }
+  clear_has_inviter_battle_tag();
+}
+inline const ::std::string& FriendInvitationParams::inviter_battle_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag)
+  return *inviter_battle_tag_;
+}
+inline void FriendInvitationParams::set_inviter_battle_tag(const ::std::string& value) {
+  set_has_inviter_battle_tag();
+  if (inviter_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_battle_tag_ = new ::std::string;
+  }
+  inviter_battle_tag_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag)
+}
+inline void FriendInvitationParams::set_inviter_battle_tag(const char* value) {
+  set_has_inviter_battle_tag();
+  if (inviter_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_battle_tag_ = new ::std::string;
+  }
+  inviter_battle_tag_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag)
+}
+inline void FriendInvitationParams::set_inviter_battle_tag(const char* value, size_t size) {
+  set_has_inviter_battle_tag();
+  if (inviter_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_battle_tag_ = new ::std::string;
+  }
+  inviter_battle_tag_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag)
+}
+inline ::std::string* FriendInvitationParams::mutable_inviter_battle_tag() {
+  set_has_inviter_battle_tag();
+  if (inviter_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_battle_tag_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag)
+  return inviter_battle_tag_;
+}
+inline ::std::string* FriendInvitationParams::release_inviter_battle_tag() {
+  clear_has_inviter_battle_tag();
+  if (inviter_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = inviter_battle_tag_;
+    inviter_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void FriendInvitationParams::set_allocated_inviter_battle_tag(::std::string* inviter_battle_tag) {
+  if (inviter_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete inviter_battle_tag_;
+  }
+  if (inviter_battle_tag) {
+    set_has_inviter_battle_tag();
+    inviter_battle_tag_ = inviter_battle_tag;
+  } else {
+    clear_has_inviter_battle_tag();
+    inviter_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendInvitationParams.inviter_battle_tag)
+}
+
+// optional string inviter_full_name = 4;
+inline bool FriendInvitationParams::has_inviter_full_name() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void FriendInvitationParams::set_has_inviter_full_name() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void FriendInvitationParams::clear_has_inviter_full_name() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void FriendInvitationParams::clear_inviter_full_name() {
+  if (inviter_full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_full_name_->clear();
+  }
+  clear_has_inviter_full_name();
+}
+inline const ::std::string& FriendInvitationParams::inviter_full_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name)
+  return *inviter_full_name_;
+}
+inline void FriendInvitationParams::set_inviter_full_name(const ::std::string& value) {
+  set_has_inviter_full_name();
+  if (inviter_full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_full_name_ = new ::std::string;
+  }
+  inviter_full_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name)
+}
+inline void FriendInvitationParams::set_inviter_full_name(const char* value) {
+  set_has_inviter_full_name();
+  if (inviter_full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_full_name_ = new ::std::string;
+  }
+  inviter_full_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name)
+}
+inline void FriendInvitationParams::set_inviter_full_name(const char* value, size_t size) {
+  set_has_inviter_full_name();
+  if (inviter_full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_full_name_ = new ::std::string;
+  }
+  inviter_full_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name)
+}
+inline ::std::string* FriendInvitationParams::mutable_inviter_full_name() {
+  set_has_inviter_full_name();
+  if (inviter_full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_full_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name)
+  return inviter_full_name_;
+}
+inline ::std::string* FriendInvitationParams::release_inviter_full_name() {
+  clear_has_inviter_full_name();
+  if (inviter_full_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = inviter_full_name_;
+    inviter_full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void FriendInvitationParams::set_allocated_inviter_full_name(::std::string* inviter_full_name) {
+  if (inviter_full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete inviter_full_name_;
+  }
+  if (inviter_full_name) {
+    set_has_inviter_full_name();
+    inviter_full_name_ = inviter_full_name;
+  } else {
+    clear_has_inviter_full_name();
+    inviter_full_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendInvitationParams.inviter_full_name)
+}
+
+// optional string invitee_display_name = 5;
+inline bool FriendInvitationParams::has_invitee_display_name() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void FriendInvitationParams::set_has_invitee_display_name() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void FriendInvitationParams::clear_has_invitee_display_name() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void FriendInvitationParams::clear_invitee_display_name() {
+  if (invitee_display_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_display_name_->clear();
+  }
+  clear_has_invitee_display_name();
+}
+inline const ::std::string& FriendInvitationParams::invitee_display_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name)
+  return *invitee_display_name_;
+}
+inline void FriendInvitationParams::set_invitee_display_name(const ::std::string& value) {
+  set_has_invitee_display_name();
+  if (invitee_display_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_display_name_ = new ::std::string;
+  }
+  invitee_display_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name)
+}
+inline void FriendInvitationParams::set_invitee_display_name(const char* value) {
+  set_has_invitee_display_name();
+  if (invitee_display_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_display_name_ = new ::std::string;
+  }
+  invitee_display_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name)
+}
+inline void FriendInvitationParams::set_invitee_display_name(const char* value, size_t size) {
+  set_has_invitee_display_name();
+  if (invitee_display_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_display_name_ = new ::std::string;
+  }
+  invitee_display_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name)
+}
+inline ::std::string* FriendInvitationParams::mutable_invitee_display_name() {
+  set_has_invitee_display_name();
+  if (invitee_display_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_display_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name)
+  return invitee_display_name_;
+}
+inline ::std::string* FriendInvitationParams::release_invitee_display_name() {
+  clear_has_invitee_display_name();
+  if (invitee_display_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = invitee_display_name_;
+    invitee_display_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void FriendInvitationParams::set_allocated_invitee_display_name(::std::string* invitee_display_name) {
+  if (invitee_display_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete invitee_display_name_;
+  }
+  if (invitee_display_name) {
+    set_has_invitee_display_name();
+    invitee_display_name_ = invitee_display_name;
+  } else {
+    clear_has_invitee_display_name();
+    invitee_display_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.friends.v1.FriendInvitationParams.invitee_display_name)
+}
+
+// repeated uint32 role = 6 [packed = true];
+inline int FriendInvitationParams::role_size() const {
+  return role_.size();
+}
+inline void FriendInvitationParams::clear_role() {
+  role_.Clear();
+}
+inline ::google::protobuf::uint32 FriendInvitationParams::role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.role)
+  return role_.Get(index);
+}
+inline void FriendInvitationParams::set_role(int index, ::google::protobuf::uint32 value) {
+  role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.role)
+}
+inline void FriendInvitationParams::add_role(::google::protobuf::uint32 value) {
+  role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.FriendInvitationParams.role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+FriendInvitationParams::role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.FriendInvitationParams.role)
+  return role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+FriendInvitationParams::mutable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.FriendInvitationParams.role)
+  return &role_;
+}
+
+// repeated uint32 previous_role_deprecated = 7 [packed = true, deprecated = true];
+inline int FriendInvitationParams::previous_role_deprecated_size() const {
+  return previous_role_deprecated_.size();
+}
+inline void FriendInvitationParams::clear_previous_role_deprecated() {
+  previous_role_deprecated_.Clear();
+}
+inline ::google::protobuf::uint32 FriendInvitationParams::previous_role_deprecated(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.friends.v1.FriendInvitationParams.previous_role_deprecated)
+  return previous_role_deprecated_.Get(index);
+}
+inline void FriendInvitationParams::set_previous_role_deprecated(int index, ::google::protobuf::uint32 value) {
+  previous_role_deprecated_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.friends.v1.FriendInvitationParams.previous_role_deprecated)
+}
+inline void FriendInvitationParams::add_previous_role_deprecated(::google::protobuf::uint32 value) {
+  previous_role_deprecated_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.friends.v1.FriendInvitationParams.previous_role_deprecated)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+FriendInvitationParams::previous_role_deprecated() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.friends.v1.FriendInvitationParams.previous_role_deprecated)
+  return previous_role_deprecated_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+FriendInvitationParams::mutable_previous_role_deprecated() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.friends.v1.FriendInvitationParams.previous_role_deprecated)
+  return &previous_role_deprecated_;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace friends
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_friends_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/game_utilities_service.pb.cc b/src/server/proto/Client/game_utilities_service.pb.cc
new file mode 100644
index 00000000000..13188964cb4
--- /dev/null
+++ b/src/server/proto/Client/game_utilities_service.pb.cc
@@ -0,0 +1,4528 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: game_utilities_service.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "game_utilities_service.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+#include "BattlenetRpcErrorCodes.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace game_utilities {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* ClientRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClientRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClientResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClientResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ServerRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ServerRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ServerResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ServerResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* PresenceChannelCreatedRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  PresenceChannelCreatedRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetPlayerVariablesRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetPlayerVariablesRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetPlayerVariablesResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetPlayerVariablesResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameAccountOnlineNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameAccountOnlineNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GameAccountOfflineNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GameAccountOfflineNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetAchievementsFileRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetAchievementsFileRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetAchievementsFileResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetAchievementsFileResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetAllValuesForAttributeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetAllValuesForAttributeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GetAllValuesForAttributeResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GetAllValuesForAttributeResponse_reflection_ = NULL;
+const ::google::protobuf::ServiceDescriptor* GameUtilitiesService_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_game_5futilities_5fservice_2eproto() {
+  protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "game_utilities_service.proto");
+  GOOGLE_CHECK(file != NULL);
+  ClientRequest_descriptor_ = file->message_type(0);
+  static const int ClientRequest_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientRequest, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientRequest, host_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientRequest, account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientRequest, game_account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientRequest, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientRequest, client_info_),
+  };
+  ClientRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClientRequest_descriptor_,
+      ClientRequest::default_instance_,
+      ClientRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClientRequest));
+  ClientResponse_descriptor_ = file->message_type(1);
+  static const int ClientResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientResponse, attribute_),
+  };
+  ClientResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClientResponse_descriptor_,
+      ClientResponse::default_instance_,
+      ClientResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClientResponse));
+  ServerRequest_descriptor_ = file->message_type(2);
+  static const int ServerRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerRequest, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerRequest, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerRequest, host_),
+  };
+  ServerRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ServerRequest_descriptor_,
+      ServerRequest::default_instance_,
+      ServerRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ServerRequest));
+  ServerResponse_descriptor_ = file->message_type(3);
+  static const int ServerResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerResponse, attribute_),
+  };
+  ServerResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ServerResponse_descriptor_,
+      ServerResponse::default_instance_,
+      ServerResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServerResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ServerResponse));
+  PresenceChannelCreatedRequest_descriptor_ = file->message_type(4);
+  static const int PresenceChannelCreatedRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PresenceChannelCreatedRequest, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PresenceChannelCreatedRequest, game_account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PresenceChannelCreatedRequest, account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PresenceChannelCreatedRequest, host_),
+  };
+  PresenceChannelCreatedRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      PresenceChannelCreatedRequest_descriptor_,
+      PresenceChannelCreatedRequest::default_instance_,
+      PresenceChannelCreatedRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PresenceChannelCreatedRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PresenceChannelCreatedRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(PresenceChannelCreatedRequest));
+  GetPlayerVariablesRequest_descriptor_ = file->message_type(5);
+  static const int GetPlayerVariablesRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetPlayerVariablesRequest, player_variables_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetPlayerVariablesRequest, host_),
+  };
+  GetPlayerVariablesRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetPlayerVariablesRequest_descriptor_,
+      GetPlayerVariablesRequest::default_instance_,
+      GetPlayerVariablesRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetPlayerVariablesRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetPlayerVariablesRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetPlayerVariablesRequest));
+  GetPlayerVariablesResponse_descriptor_ = file->message_type(6);
+  static const int GetPlayerVariablesResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetPlayerVariablesResponse, player_variables_),
+  };
+  GetPlayerVariablesResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetPlayerVariablesResponse_descriptor_,
+      GetPlayerVariablesResponse::default_instance_,
+      GetPlayerVariablesResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetPlayerVariablesResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetPlayerVariablesResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetPlayerVariablesResponse));
+  GameAccountOnlineNotification_descriptor_ = file->message_type(7);
+  static const int GameAccountOnlineNotification_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOnlineNotification, game_account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOnlineNotification, host_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOnlineNotification, session_id_),
+  };
+  GameAccountOnlineNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameAccountOnlineNotification_descriptor_,
+      GameAccountOnlineNotification::default_instance_,
+      GameAccountOnlineNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOnlineNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOnlineNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameAccountOnlineNotification));
+  GameAccountOfflineNotification_descriptor_ = file->message_type(8);
+  static const int GameAccountOfflineNotification_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOfflineNotification, game_account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOfflineNotification, host_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOfflineNotification, session_id_),
+  };
+  GameAccountOfflineNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GameAccountOfflineNotification_descriptor_,
+      GameAccountOfflineNotification::default_instance_,
+      GameAccountOfflineNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOfflineNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GameAccountOfflineNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GameAccountOfflineNotification));
+  GetAchievementsFileRequest_descriptor_ = file->message_type(9);
+  static const int GetAchievementsFileRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAchievementsFileRequest, host_),
+  };
+  GetAchievementsFileRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetAchievementsFileRequest_descriptor_,
+      GetAchievementsFileRequest::default_instance_,
+      GetAchievementsFileRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAchievementsFileRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAchievementsFileRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetAchievementsFileRequest));
+  GetAchievementsFileResponse_descriptor_ = file->message_type(10);
+  static const int GetAchievementsFileResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAchievementsFileResponse, content_handle_),
+  };
+  GetAchievementsFileResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetAchievementsFileResponse_descriptor_,
+      GetAchievementsFileResponse::default_instance_,
+      GetAchievementsFileResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAchievementsFileResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAchievementsFileResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetAchievementsFileResponse));
+  GetAllValuesForAttributeRequest_descriptor_ = file->message_type(11);
+  static const int GetAllValuesForAttributeRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAllValuesForAttributeRequest, attribute_key_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAllValuesForAttributeRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAllValuesForAttributeRequest, program_),
+  };
+  GetAllValuesForAttributeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetAllValuesForAttributeRequest_descriptor_,
+      GetAllValuesForAttributeRequest::default_instance_,
+      GetAllValuesForAttributeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAllValuesForAttributeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAllValuesForAttributeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetAllValuesForAttributeRequest));
+  GetAllValuesForAttributeResponse_descriptor_ = file->message_type(12);
+  static const int GetAllValuesForAttributeResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAllValuesForAttributeResponse, attribute_value_),
+  };
+  GetAllValuesForAttributeResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GetAllValuesForAttributeResponse_descriptor_,
+      GetAllValuesForAttributeResponse::default_instance_,
+      GetAllValuesForAttributeResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAllValuesForAttributeResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GetAllValuesForAttributeResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GetAllValuesForAttributeResponse));
+  GameUtilitiesService_descriptor_ = file->service(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_game_5futilities_5fservice_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClientRequest_descriptor_, &ClientRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClientResponse_descriptor_, &ClientResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ServerRequest_descriptor_, &ServerRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ServerResponse_descriptor_, &ServerResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    PresenceChannelCreatedRequest_descriptor_, &PresenceChannelCreatedRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetPlayerVariablesRequest_descriptor_, &GetPlayerVariablesRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetPlayerVariablesResponse_descriptor_, &GetPlayerVariablesResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameAccountOnlineNotification_descriptor_, &GameAccountOnlineNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GameAccountOfflineNotification_descriptor_, &GameAccountOfflineNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetAchievementsFileRequest_descriptor_, &GetAchievementsFileRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetAchievementsFileResponse_descriptor_, &GetAchievementsFileResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetAllValuesForAttributeRequest_descriptor_, &GetAllValuesForAttributeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GetAllValuesForAttributeResponse_descriptor_, &GetAllValuesForAttributeResponse::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto() {
+  delete ClientRequest::default_instance_;
+  delete ClientRequest_reflection_;
+  delete ClientResponse::default_instance_;
+  delete ClientResponse_reflection_;
+  delete ServerRequest::default_instance_;
+  delete ServerRequest_reflection_;
+  delete ServerResponse::default_instance_;
+  delete ServerResponse_reflection_;
+  delete PresenceChannelCreatedRequest::default_instance_;
+  delete PresenceChannelCreatedRequest_reflection_;
+  delete GetPlayerVariablesRequest::default_instance_;
+  delete GetPlayerVariablesRequest_reflection_;
+  delete GetPlayerVariablesResponse::default_instance_;
+  delete GetPlayerVariablesResponse_reflection_;
+  delete GameAccountOnlineNotification::default_instance_;
+  delete GameAccountOnlineNotification_reflection_;
+  delete GameAccountOfflineNotification::default_instance_;
+  delete GameAccountOfflineNotification_reflection_;
+  delete GetAchievementsFileRequest::default_instance_;
+  delete GetAchievementsFileRequest_reflection_;
+  delete GetAchievementsFileResponse::default_instance_;
+  delete GetAchievementsFileResponse_reflection_;
+  delete GetAllValuesForAttributeRequest::default_instance_;
+  delete GetAllValuesForAttributeRequest_reflection_;
+  delete GetAllValuesForAttributeResponse::default_instance_;
+  delete GetAllValuesForAttributeResponse_reflection_;
+}
+
+void protobuf_AddDesc_game_5futilities_5fservice_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_content_5fhandle_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::bgs::protocol::game_utilities::v1::protobuf_AddDesc_game_5futilities_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\034game_utilities_service.proto\022\036bgs.prot"
+    "ocol.game_utilities.v1\032\025attribute_types."
+    "proto\032\032content_handle_types.proto\032\022entit"
+    "y_types.proto\032\032game_utilities_types.prot"
+    "o\032\017rpc_types.proto\"\221\002\n\rClientRequest\022*\n\t"
+    "attribute\030\001 \003(\0132\027.bgs.protocol.Attribute"
+    "\022%\n\004host\030\002 \001(\0132\027.bgs.protocol.ProcessId\022"
+    "*\n\naccount_id\030\003 \001(\0132\026.bgs.protocol.Entit"
+    "yId\022/\n\017game_account_id\030\004 \001(\0132\026.bgs.proto"
+    "col.EntityId\022\017\n\007program\030\005 \001(\007\022\?\n\013client_"
+    "info\030\006 \001(\0132*.bgs.protocol.game_utilities"
+    ".v1.ClientInfo\"<\n\016ClientResponse\022*\n\tattr"
+    "ibute\030\001 \003(\0132\027.bgs.protocol.Attribute\"s\n\r"
+    "ServerRequest\022*\n\tattribute\030\001 \003(\0132\027.bgs.p"
+    "rotocol.Attribute\022\017\n\007program\030\002 \002(\007\022%\n\004ho"
+    "st\030\003 \001(\0132\027.bgs.protocol.ProcessId\"<\n\016Ser"
+    "verResponse\022*\n\tattribute\030\001 \003(\0132\027.bgs.pro"
+    "tocol.Attribute\"\307\001\n\035PresenceChannelCreat"
+    "edRequest\022\"\n\002id\030\001 \002(\0132\026.bgs.protocol.Ent"
+    "ityId\022/\n\017game_account_id\030\003 \001(\0132\026.bgs.pro"
+    "tocol.EntityId\022*\n\naccount_id\030\004 \001(\0132\026.bgs"
+    ".protocol.EntityId\022%\n\004host\030\005 \001(\0132\027.bgs.p"
+    "rotocol.ProcessId\"\215\001\n\031GetPlayerVariables"
+    "Request\022I\n\020player_variables\030\001 \003(\0132/.bgs."
+    "protocol.game_utilities.v1.PlayerVariabl"
+    "es\022%\n\004host\030\002 \001(\0132\027.bgs.protocol.ProcessI"
+    "d\"g\n\032GetPlayerVariablesResponse\022I\n\020playe"
+    "r_variables\030\001 \003(\0132/.bgs.protocol.game_ut"
+    "ilities.v1.PlayerVariables\"\213\001\n\035GameAccou"
+    "ntOnlineNotification\022/\n\017game_account_id\030"
+    "\001 \002(\0132\026.bgs.protocol.EntityId\022%\n\004host\030\002 "
+    "\001(\0132\027.bgs.protocol.ProcessId\022\022\n\nsession_"
+    "id\030\003 \001(\t\"\214\001\n\036GameAccountOfflineNotificat"
+    "ion\022/\n\017game_account_id\030\001 \002(\0132\026.bgs.proto"
+    "col.EntityId\022%\n\004host\030\002 \001(\0132\027.bgs.protoco"
+    "l.ProcessId\022\022\n\nsession_id\030\003 \001(\t\"C\n\032GetAc"
+    "hievementsFileRequest\022%\n\004host\030\001 \001(\0132\027.bg"
+    "s.protocol.ProcessId\"R\n\033GetAchievementsF"
+    "ileResponse\0223\n\016content_handle\030\001 \001(\0132\033.bg"
+    "s.protocol.ContentHandle\"s\n\037GetAllValues"
+    "ForAttributeRequest\022\025\n\rattribute_key\030\001 \001"
+    "(\t\022(\n\010agent_id\030\002 \001(\0132\026.bgs.protocol.Enti"
+    "tyId\022\017\n\007program\030\005 \001(\007\"R\n GetAllValuesFor"
+    "AttributeResponse\022.\n\017attribute_value\030\001 \003"
+    "(\0132\025.bgs.protocol.Variant2\365\010\n\024GameUtilit"
+    "iesService\022{\n\024ProcessClientRequest\022-.bgs"
+    ".protocol.game_utilities.v1.ClientReques"
+    "t\032..bgs.protocol.game_utilities.v1.Clien"
+    "tResponse\"\004\200\265\030\001\022s\n\026PresenceChannelCreate"
+    "d\022=.bgs.protocol.game_utilities.v1.Prese"
+    "nceChannelCreatedRequest\032\024.bgs.protocol."
+    "NoData\"\004\200\265\030\002\022\221\001\n\022GetPlayerVariables\0229.bg"
+    "s.protocol.game_utilities.v1.GetPlayerVa"
+    "riablesRequest\032:.bgs.protocol.game_utili"
+    "ties.v1.GetPlayerVariablesResponse\"\004\200\265\030\003"
+    "\022{\n\024ProcessServerRequest\022-.bgs.protocol."
+    "game_utilities.v1.ServerRequest\032..bgs.pr"
+    "otocol.game_utilities.v1.ServerResponse\""
+    "\004\200\265\030\006\022u\n\023OnGameAccountOnline\022=.bgs.proto"
+    "col.game_utilities.v1.GameAccountOnlineN"
+    "otification\032\031.bgs.protocol.NO_RESPONSE\"\004"
+    "\200\265\030\007\022w\n\024OnGameAccountOffline\022>.bgs.proto"
+    "col.game_utilities.v1.GameAccountOffline"
+    "Notification\032\031.bgs.protocol.NO_RESPONSE\""
+    "\004\200\265\030\010\022\224\001\n\023GetAchievementsFile\022:.bgs.prot"
+    "ocol.game_utilities.v1.GetAchievementsFi"
+    "leRequest\032;.bgs.protocol.game_utilities."
+    "v1.GetAchievementsFileResponse\"\004\200\265\030\t\022\243\001\n"
+    "\030GetAllValuesForAttribute\022\?.bgs.protocol"
+    ".game_utilities.v1.GetAllValuesForAttrib"
+    "uteRequest\032@.bgs.protocol.game_utilities"
+    ".v1.GetAllValuesForAttributeResponse\"\004\200\265"
+    "\030\n\032-\312>*bnet.protocol.game_utilities.Game"
+    "UtilitiesBD\n\037bnet.protocol.game_utilitie"
+    "s.v1B\031GameUtilitiesServiceProtoH\001\200\001\000\210\001\001", 2999);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "game_utilities_service.proto", &protobuf_RegisterTypes);
+  ClientRequest::default_instance_ = new ClientRequest();
+  ClientResponse::default_instance_ = new ClientResponse();
+  ServerRequest::default_instance_ = new ServerRequest();
+  ServerResponse::default_instance_ = new ServerResponse();
+  PresenceChannelCreatedRequest::default_instance_ = new PresenceChannelCreatedRequest();
+  GetPlayerVariablesRequest::default_instance_ = new GetPlayerVariablesRequest();
+  GetPlayerVariablesResponse::default_instance_ = new GetPlayerVariablesResponse();
+  GameAccountOnlineNotification::default_instance_ = new GameAccountOnlineNotification();
+  GameAccountOfflineNotification::default_instance_ = new GameAccountOfflineNotification();
+  GetAchievementsFileRequest::default_instance_ = new GetAchievementsFileRequest();
+  GetAchievementsFileResponse::default_instance_ = new GetAchievementsFileResponse();
+  GetAllValuesForAttributeRequest::default_instance_ = new GetAllValuesForAttributeRequest();
+  GetAllValuesForAttributeResponse::default_instance_ = new GetAllValuesForAttributeResponse();
+  ClientRequest::default_instance_->InitAsDefaultInstance();
+  ClientResponse::default_instance_->InitAsDefaultInstance();
+  ServerRequest::default_instance_->InitAsDefaultInstance();
+  ServerResponse::default_instance_->InitAsDefaultInstance();
+  PresenceChannelCreatedRequest::default_instance_->InitAsDefaultInstance();
+  GetPlayerVariablesRequest::default_instance_->InitAsDefaultInstance();
+  GetPlayerVariablesResponse::default_instance_->InitAsDefaultInstance();
+  GameAccountOnlineNotification::default_instance_->InitAsDefaultInstance();
+  GameAccountOfflineNotification::default_instance_->InitAsDefaultInstance();
+  GetAchievementsFileRequest::default_instance_->InitAsDefaultInstance();
+  GetAchievementsFileResponse::default_instance_->InitAsDefaultInstance();
+  GetAllValuesForAttributeRequest::default_instance_->InitAsDefaultInstance();
+  GetAllValuesForAttributeResponse::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_game_5futilities_5fservice_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_game_5futilities_5fservice_2eproto {
+  StaticDescriptorInitializer_game_5futilities_5fservice_2eproto() {
+    protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  }
+} static_descriptor_initializer_game_5futilities_5fservice_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClientRequest::kAttributeFieldNumber;
+const int ClientRequest::kHostFieldNumber;
+const int ClientRequest::kAccountIdFieldNumber;
+const int ClientRequest::kGameAccountIdFieldNumber;
+const int ClientRequest::kProgramFieldNumber;
+const int ClientRequest::kClientInfoFieldNumber;
+#endif  // !_MSC_VER
+
+ClientRequest::ClientRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.ClientRequest)
+}
+
+void ClientRequest::InitAsDefaultInstance() {
+  host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  client_info_ = const_cast< ::bgs::protocol::game_utilities::v1::ClientInfo*>(&::bgs::protocol::game_utilities::v1::ClientInfo::default_instance());
+}
+
+ClientRequest::ClientRequest(const ClientRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.ClientRequest)
+}
+
+void ClientRequest::SharedCtor() {
+  _cached_size_ = 0;
+  host_ = NULL;
+  account_id_ = NULL;
+  game_account_id_ = NULL;
+  program_ = 0u;
+  client_info_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientRequest::~ClientRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.ClientRequest)
+  SharedDtor();
+}
+
+void ClientRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete host_;
+    delete account_id_;
+    delete game_account_id_;
+    delete client_info_;
+  }
+}
+
+void ClientRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClientRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClientRequest_descriptor_;
+}
+
+const ClientRequest& ClientRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ClientRequest* ClientRequest::default_instance_ = NULL;
+
+ClientRequest* ClientRequest::New() const {
+  return new ClientRequest;
+}
+
+void ClientRequest::Clear() {
+  if (_has_bits_[0 / 32] & 62) {
+    if (has_host()) {
+      if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+    }
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_game_account_id()) {
+      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    program_ = 0u;
+    if (has_client_info()) {
+      if (client_info_ != NULL) client_info_->::bgs::protocol::game_utilities::v1::ClientInfo::Clear();
+    }
+  }
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClientRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.ClientRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.Attribute attribute = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_attribute;
+        if (input->ExpectTag(18)) goto parse_host;
+        break;
+      }
+
+      // optional .bgs.protocol.ProcessId host = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_host:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_host()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId account_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_game_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId game_account_id = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_game_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(45)) goto parse_program;
+        break;
+      }
+
+      // optional fixed32 program = 5;
+      case 5: {
+        if (tag == 45) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_client_info;
+        break;
+      }
+
+      // optional .bgs.protocol.game_utilities.v1.ClientInfo client_info = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_client_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_client_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.game_utilities.v1.ClientRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.ClientRequest)
+  return false;
+#undef DO_
+}
+
+void ClientRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.ClientRequest)
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->attribute(i), output);
+  }
+
+  // optional .bgs.protocol.ProcessId host = 2;
+  if (has_host()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->host(), output);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 3;
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->account_id(), output);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 4;
+  if (has_game_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->game_account_id(), output);
+  }
+
+  // optional fixed32 program = 5;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->program(), output);
+  }
+
+  // optional .bgs.protocol.game_utilities.v1.ClientInfo client_info = 6;
+  if (has_client_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->client_info(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.ClientRequest)
+}
+
+::google::protobuf::uint8* ClientRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.ClientRequest)
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->attribute(i), target);
+  }
+
+  // optional .bgs.protocol.ProcessId host = 2;
+  if (has_host()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->host(), target);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 3;
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->account_id(), target);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 4;
+  if (has_game_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->game_account_id(), target);
+  }
+
+  // optional fixed32 program = 5;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->program(), target);
+  }
+
+  // optional .bgs.protocol.game_utilities.v1.ClientInfo client_info = 6;
+  if (has_client_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->client_info(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.ClientRequest)
+  return target;
+}
+
+int ClientRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional .bgs.protocol.ProcessId host = 2;
+    if (has_host()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->host());
+    }
+
+    // optional .bgs.protocol.EntityId account_id = 3;
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+    // optional .bgs.protocol.EntityId game_account_id = 4;
+    if (has_game_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_id());
+    }
+
+    // optional fixed32 program = 5;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+    // optional .bgs.protocol.game_utilities.v1.ClientInfo client_info = 6;
+    if (has_client_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->client_info());
+    }
+
+  }
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClientRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClientRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClientRequest::MergeFrom(const ClientRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_host()) {
+      mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host());
+    }
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
+    }
+    if (from.has_game_account_id()) {
+      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_client_info()) {
+      mutable_client_info()->::bgs::protocol::game_utilities::v1::ClientInfo::MergeFrom(from.client_info());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClientRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClientRequest::CopyFrom(const ClientRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientRequest::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
+  if (has_host()) {
+    if (!this->host().IsInitialized()) return false;
+  }
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  if (has_game_account_id()) {
+    if (!this->game_account_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClientRequest::Swap(ClientRequest* other) {
+  if (other != this) {
+    attribute_.Swap(&other->attribute_);
+    std::swap(host_, other->host_);
+    std::swap(account_id_, other->account_id_);
+    std::swap(game_account_id_, other->game_account_id_);
+    std::swap(program_, other->program_);
+    std::swap(client_info_, other->client_info_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClientRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClientRequest_descriptor_;
+  metadata.reflection = ClientRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClientResponse::kAttributeFieldNumber;
+#endif  // !_MSC_VER
+
+ClientResponse::ClientResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.ClientResponse)
+}
+
+void ClientResponse::InitAsDefaultInstance() {
+}
+
+ClientResponse::ClientResponse(const ClientResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.ClientResponse)
+}
+
+void ClientResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientResponse::~ClientResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.ClientResponse)
+  SharedDtor();
+}
+
+void ClientResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ClientResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClientResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClientResponse_descriptor_;
+}
+
+const ClientResponse& ClientResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ClientResponse* ClientResponse::default_instance_ = NULL;
+
+ClientResponse* ClientResponse::New() const {
+  return new ClientResponse;
+}
+
+void ClientResponse::Clear() {
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClientResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.ClientResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.Attribute attribute = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_attribute;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.game_utilities.v1.ClientResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.ClientResponse)
+  return false;
+#undef DO_
+}
+
+void ClientResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.ClientResponse)
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->attribute(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.ClientResponse)
+}
+
+::google::protobuf::uint8* ClientResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.ClientResponse)
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->attribute(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.ClientResponse)
+  return target;
+}
+
+int ClientResponse::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClientResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClientResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClientResponse::MergeFrom(const ClientResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClientResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClientResponse::CopyFrom(const ClientResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
+  return true;
+}
+
+void ClientResponse::Swap(ClientResponse* other) {
+  if (other != this) {
+    attribute_.Swap(&other->attribute_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClientResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClientResponse_descriptor_;
+  metadata.reflection = ClientResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ServerRequest::kAttributeFieldNumber;
+const int ServerRequest::kProgramFieldNumber;
+const int ServerRequest::kHostFieldNumber;
+#endif  // !_MSC_VER
+
+ServerRequest::ServerRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.ServerRequest)
+}
+
+void ServerRequest::InitAsDefaultInstance() {
+  host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+}
+
+ServerRequest::ServerRequest(const ServerRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.ServerRequest)
+}
+
+void ServerRequest::SharedCtor() {
+  _cached_size_ = 0;
+  program_ = 0u;
+  host_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ServerRequest::~ServerRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.ServerRequest)
+  SharedDtor();
+}
+
+void ServerRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete host_;
+  }
+}
+
+void ServerRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ServerRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ServerRequest_descriptor_;
+}
+
+const ServerRequest& ServerRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ServerRequest* ServerRequest::default_instance_ = NULL;
+
+ServerRequest* ServerRequest::New() const {
+  return new ServerRequest;
+}
+
+void ServerRequest::Clear() {
+  if (_has_bits_[0 / 32] & 6) {
+    program_ = 0u;
+    if (has_host()) {
+      if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+    }
+  }
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ServerRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.ServerRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.Attribute attribute = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_attribute;
+        if (input->ExpectTag(21)) goto parse_program;
+        break;
+      }
+
+      // required fixed32 program = 2;
+      case 2: {
+        if (tag == 21) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_host;
+        break;
+      }
+
+      // optional .bgs.protocol.ProcessId host = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_host:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_host()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.game_utilities.v1.ServerRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.ServerRequest)
+  return false;
+#undef DO_
+}
+
+void ServerRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.ServerRequest)
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->attribute(i), output);
+  }
+
+  // required fixed32 program = 2;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->program(), output);
+  }
+
+  // optional .bgs.protocol.ProcessId host = 3;
+  if (has_host()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->host(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.ServerRequest)
+}
+
+::google::protobuf::uint8* ServerRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.ServerRequest)
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->attribute(i), target);
+  }
+
+  // required fixed32 program = 2;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->program(), target);
+  }
+
+  // optional .bgs.protocol.ProcessId host = 3;
+  if (has_host()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->host(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.ServerRequest)
+  return target;
+}
+
+int ServerRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // required fixed32 program = 2;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+    // optional .bgs.protocol.ProcessId host = 3;
+    if (has_host()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->host());
+    }
+
+  }
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ServerRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ServerRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ServerRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ServerRequest::MergeFrom(const ServerRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_host()) {
+      mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ServerRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ServerRequest::CopyFrom(const ServerRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ServerRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
+  if (has_host()) {
+    if (!this->host().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ServerRequest::Swap(ServerRequest* other) {
+  if (other != this) {
+    attribute_.Swap(&other->attribute_);
+    std::swap(program_, other->program_);
+    std::swap(host_, other->host_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ServerRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ServerRequest_descriptor_;
+  metadata.reflection = ServerRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ServerResponse::kAttributeFieldNumber;
+#endif  // !_MSC_VER
+
+ServerResponse::ServerResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.ServerResponse)
+}
+
+void ServerResponse::InitAsDefaultInstance() {
+}
+
+ServerResponse::ServerResponse(const ServerResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.ServerResponse)
+}
+
+void ServerResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ServerResponse::~ServerResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.ServerResponse)
+  SharedDtor();
+}
+
+void ServerResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ServerResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ServerResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ServerResponse_descriptor_;
+}
+
+const ServerResponse& ServerResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ServerResponse* ServerResponse::default_instance_ = NULL;
+
+ServerResponse* ServerResponse::New() const {
+  return new ServerResponse;
+}
+
+void ServerResponse::Clear() {
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ServerResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.ServerResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.Attribute attribute = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_attribute;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.game_utilities.v1.ServerResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.ServerResponse)
+  return false;
+#undef DO_
+}
+
+void ServerResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.ServerResponse)
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->attribute(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.ServerResponse)
+}
+
+::google::protobuf::uint8* ServerResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.ServerResponse)
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->attribute(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.ServerResponse)
+  return target;
+}
+
+int ServerResponse::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.Attribute attribute = 1;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ServerResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ServerResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ServerResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ServerResponse::MergeFrom(const ServerResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ServerResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ServerResponse::CopyFrom(const ServerResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ServerResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
+  return true;
+}
+
+void ServerResponse::Swap(ServerResponse* other) {
+  if (other != this) {
+    attribute_.Swap(&other->attribute_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ServerResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ServerResponse_descriptor_;
+  metadata.reflection = ServerResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int PresenceChannelCreatedRequest::kIdFieldNumber;
+const int PresenceChannelCreatedRequest::kGameAccountIdFieldNumber;
+const int PresenceChannelCreatedRequest::kAccountIdFieldNumber;
+const int PresenceChannelCreatedRequest::kHostFieldNumber;
+#endif  // !_MSC_VER
+
+PresenceChannelCreatedRequest::PresenceChannelCreatedRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest)
+}
+
+void PresenceChannelCreatedRequest::InitAsDefaultInstance() {
+  id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+}
+
+PresenceChannelCreatedRequest::PresenceChannelCreatedRequest(const PresenceChannelCreatedRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest)
+}
+
+void PresenceChannelCreatedRequest::SharedCtor() {
+  _cached_size_ = 0;
+  id_ = NULL;
+  game_account_id_ = NULL;
+  account_id_ = NULL;
+  host_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+PresenceChannelCreatedRequest::~PresenceChannelCreatedRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest)
+  SharedDtor();
+}
+
+void PresenceChannelCreatedRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete id_;
+    delete game_account_id_;
+    delete account_id_;
+    delete host_;
+  }
+}
+
+void PresenceChannelCreatedRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* PresenceChannelCreatedRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PresenceChannelCreatedRequest_descriptor_;
+}
+
+const PresenceChannelCreatedRequest& PresenceChannelCreatedRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  return *default_instance_;
+}
+
+PresenceChannelCreatedRequest* PresenceChannelCreatedRequest::default_instance_ = NULL;
+
+PresenceChannelCreatedRequest* PresenceChannelCreatedRequest::New() const {
+  return new PresenceChannelCreatedRequest;
+}
+
+void PresenceChannelCreatedRequest::Clear() {
+  if (_has_bits_[0 / 32] & 15) {
+    if (has_id()) {
+      if (id_ != NULL) id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_game_account_id()) {
+      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_host()) {
+      if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool PresenceChannelCreatedRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.EntityId id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_game_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId game_account_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_game_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId account_id = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_host;
+        break;
+      }
+
+      // optional .bgs.protocol.ProcessId host = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_host:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_host()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest)
+  return false;
+#undef DO_
+}
+
+void PresenceChannelCreatedRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest)
+  // required .bgs.protocol.EntityId id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->id(), output);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 3;
+  if (has_game_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->game_account_id(), output);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 4;
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->account_id(), output);
+  }
+
+  // optional .bgs.protocol.ProcessId host = 5;
+  if (has_host()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->host(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest)
+}
+
+::google::protobuf::uint8* PresenceChannelCreatedRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest)
+  // required .bgs.protocol.EntityId id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->id(), target);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 3;
+  if (has_game_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->game_account_id(), target);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 4;
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->account_id(), target);
+  }
+
+  // optional .bgs.protocol.ProcessId host = 5;
+  if (has_host()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->host(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest)
+  return target;
+}
+
+int PresenceChannelCreatedRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.EntityId id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->id());
+    }
+
+    // optional .bgs.protocol.EntityId game_account_id = 3;
+    if (has_game_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_id());
+    }
+
+    // optional .bgs.protocol.EntityId account_id = 4;
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+    // optional .bgs.protocol.ProcessId host = 5;
+    if (has_host()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->host());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void PresenceChannelCreatedRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const PresenceChannelCreatedRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const PresenceChannelCreatedRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void PresenceChannelCreatedRequest::MergeFrom(const PresenceChannelCreatedRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      mutable_id()->::bgs::protocol::EntityId::MergeFrom(from.id());
+    }
+    if (from.has_game_account_id()) {
+      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+    }
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
+    }
+    if (from.has_host()) {
+      mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PresenceChannelCreatedRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void PresenceChannelCreatedRequest::CopyFrom(const PresenceChannelCreatedRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PresenceChannelCreatedRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_id()) {
+    if (!this->id().IsInitialized()) return false;
+  }
+  if (has_game_account_id()) {
+    if (!this->game_account_id().IsInitialized()) return false;
+  }
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  if (has_host()) {
+    if (!this->host().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void PresenceChannelCreatedRequest::Swap(PresenceChannelCreatedRequest* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(game_account_id_, other->game_account_id_);
+    std::swap(account_id_, other->account_id_);
+    std::swap(host_, other->host_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata PresenceChannelCreatedRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = PresenceChannelCreatedRequest_descriptor_;
+  metadata.reflection = PresenceChannelCreatedRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetPlayerVariablesRequest::kPlayerVariablesFieldNumber;
+const int GetPlayerVariablesRequest::kHostFieldNumber;
+#endif  // !_MSC_VER
+
+GetPlayerVariablesRequest::GetPlayerVariablesRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest)
+}
+
+void GetPlayerVariablesRequest::InitAsDefaultInstance() {
+  host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+}
+
+GetPlayerVariablesRequest::GetPlayerVariablesRequest(const GetPlayerVariablesRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest)
+}
+
+void GetPlayerVariablesRequest::SharedCtor() {
+  _cached_size_ = 0;
+  host_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetPlayerVariablesRequest::~GetPlayerVariablesRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest)
+  SharedDtor();
+}
+
+void GetPlayerVariablesRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete host_;
+  }
+}
+
+void GetPlayerVariablesRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetPlayerVariablesRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetPlayerVariablesRequest_descriptor_;
+}
+
+const GetPlayerVariablesRequest& GetPlayerVariablesRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetPlayerVariablesRequest* GetPlayerVariablesRequest::default_instance_ = NULL;
+
+GetPlayerVariablesRequest* GetPlayerVariablesRequest::New() const {
+  return new GetPlayerVariablesRequest;
+}
+
+void GetPlayerVariablesRequest::Clear() {
+  if (has_host()) {
+    if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+  }
+  player_variables_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetPlayerVariablesRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_player_variables:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_player_variables()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_player_variables;
+        if (input->ExpectTag(18)) goto parse_host;
+        break;
+      }
+
+      // optional .bgs.protocol.ProcessId host = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_host:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_host()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest)
+  return false;
+#undef DO_
+}
+
+void GetPlayerVariablesRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest)
+  // repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1;
+  for (int i = 0; i < this->player_variables_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->player_variables(i), output);
+  }
+
+  // optional .bgs.protocol.ProcessId host = 2;
+  if (has_host()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->host(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest)
+}
+
+::google::protobuf::uint8* GetPlayerVariablesRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest)
+  // repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1;
+  for (int i = 0; i < this->player_variables_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->player_variables(i), target);
+  }
+
+  // optional .bgs.protocol.ProcessId host = 2;
+  if (has_host()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->host(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest)
+  return target;
+}
+
+int GetPlayerVariablesRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional .bgs.protocol.ProcessId host = 2;
+    if (has_host()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->host());
+    }
+
+  }
+  // repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1;
+  total_size += 1 * this->player_variables_size();
+  for (int i = 0; i < this->player_variables_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->player_variables(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetPlayerVariablesRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetPlayerVariablesRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetPlayerVariablesRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetPlayerVariablesRequest::MergeFrom(const GetPlayerVariablesRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  player_variables_.MergeFrom(from.player_variables_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_host()) {
+      mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetPlayerVariablesRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetPlayerVariablesRequest::CopyFrom(const GetPlayerVariablesRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetPlayerVariablesRequest::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->player_variables())) return false;
+  if (has_host()) {
+    if (!this->host().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetPlayerVariablesRequest::Swap(GetPlayerVariablesRequest* other) {
+  if (other != this) {
+    player_variables_.Swap(&other->player_variables_);
+    std::swap(host_, other->host_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetPlayerVariablesRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetPlayerVariablesRequest_descriptor_;
+  metadata.reflection = GetPlayerVariablesRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetPlayerVariablesResponse::kPlayerVariablesFieldNumber;
+#endif  // !_MSC_VER
+
+GetPlayerVariablesResponse::GetPlayerVariablesResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse)
+}
+
+void GetPlayerVariablesResponse::InitAsDefaultInstance() {
+}
+
+GetPlayerVariablesResponse::GetPlayerVariablesResponse(const GetPlayerVariablesResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse)
+}
+
+void GetPlayerVariablesResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetPlayerVariablesResponse::~GetPlayerVariablesResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse)
+  SharedDtor();
+}
+
+void GetPlayerVariablesResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GetPlayerVariablesResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetPlayerVariablesResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetPlayerVariablesResponse_descriptor_;
+}
+
+const GetPlayerVariablesResponse& GetPlayerVariablesResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetPlayerVariablesResponse* GetPlayerVariablesResponse::default_instance_ = NULL;
+
+GetPlayerVariablesResponse* GetPlayerVariablesResponse::New() const {
+  return new GetPlayerVariablesResponse;
+}
+
+void GetPlayerVariablesResponse::Clear() {
+  player_variables_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetPlayerVariablesResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_player_variables:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_player_variables()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_player_variables;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse)
+  return false;
+#undef DO_
+}
+
+void GetPlayerVariablesResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse)
+  // repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1;
+  for (int i = 0; i < this->player_variables_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->player_variables(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse)
+}
+
+::google::protobuf::uint8* GetPlayerVariablesResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse)
+  // repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1;
+  for (int i = 0; i < this->player_variables_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->player_variables(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse)
+  return target;
+}
+
+int GetPlayerVariablesResponse::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1;
+  total_size += 1 * this->player_variables_size();
+  for (int i = 0; i < this->player_variables_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->player_variables(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetPlayerVariablesResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetPlayerVariablesResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetPlayerVariablesResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetPlayerVariablesResponse::MergeFrom(const GetPlayerVariablesResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  player_variables_.MergeFrom(from.player_variables_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetPlayerVariablesResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetPlayerVariablesResponse::CopyFrom(const GetPlayerVariablesResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetPlayerVariablesResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->player_variables())) return false;
+  return true;
+}
+
+void GetPlayerVariablesResponse::Swap(GetPlayerVariablesResponse* other) {
+  if (other != this) {
+    player_variables_.Swap(&other->player_variables_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetPlayerVariablesResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetPlayerVariablesResponse_descriptor_;
+  metadata.reflection = GetPlayerVariablesResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameAccountOnlineNotification::kGameAccountIdFieldNumber;
+const int GameAccountOnlineNotification::kHostFieldNumber;
+const int GameAccountOnlineNotification::kSessionIdFieldNumber;
+#endif  // !_MSC_VER
+
+GameAccountOnlineNotification::GameAccountOnlineNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification)
+}
+
+void GameAccountOnlineNotification::InitAsDefaultInstance() {
+  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+}
+
+GameAccountOnlineNotification::GameAccountOnlineNotification(const GameAccountOnlineNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification)
+}
+
+void GameAccountOnlineNotification::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  game_account_id_ = NULL;
+  host_ = NULL;
+  session_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameAccountOnlineNotification::~GameAccountOnlineNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification)
+  SharedDtor();
+}
+
+void GameAccountOnlineNotification::SharedDtor() {
+  if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete session_id_;
+  }
+  if (this != default_instance_) {
+    delete game_account_id_;
+    delete host_;
+  }
+}
+
+void GameAccountOnlineNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameAccountOnlineNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameAccountOnlineNotification_descriptor_;
+}
+
+const GameAccountOnlineNotification& GameAccountOnlineNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GameAccountOnlineNotification* GameAccountOnlineNotification::default_instance_ = NULL;
+
+GameAccountOnlineNotification* GameAccountOnlineNotification::New() const {
+  return new GameAccountOnlineNotification;
+}
+
+void GameAccountOnlineNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_game_account_id()) {
+      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_host()) {
+      if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+    }
+    if (has_session_id()) {
+      if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        session_id_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameAccountOnlineNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.EntityId game_account_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_host;
+        break;
+      }
+
+      // optional .bgs.protocol.ProcessId host = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_host:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_host()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_session_id;
+        break;
+      }
+
+      // optional string session_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_session_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_session_id()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->session_id().data(), this->session_id().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "session_id");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification)
+  return false;
+#undef DO_
+}
+
+void GameAccountOnlineNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification)
+  // required .bgs.protocol.EntityId game_account_id = 1;
+  if (has_game_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->game_account_id(), output);
+  }
+
+  // optional .bgs.protocol.ProcessId host = 2;
+  if (has_host()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->host(), output);
+  }
+
+  // optional string session_id = 3;
+  if (has_session_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->session_id().data(), this->session_id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "session_id");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->session_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification)
+}
+
+::google::protobuf::uint8* GameAccountOnlineNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification)
+  // required .bgs.protocol.EntityId game_account_id = 1;
+  if (has_game_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->game_account_id(), target);
+  }
+
+  // optional .bgs.protocol.ProcessId host = 2;
+  if (has_host()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->host(), target);
+  }
+
+  // optional string session_id = 3;
+  if (has_session_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->session_id().data(), this->session_id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "session_id");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->session_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification)
+  return target;
+}
+
+int GameAccountOnlineNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.EntityId game_account_id = 1;
+    if (has_game_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_id());
+    }
+
+    // optional .bgs.protocol.ProcessId host = 2;
+    if (has_host()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->host());
+    }
+
+    // optional string session_id = 3;
+    if (has_session_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->session_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameAccountOnlineNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameAccountOnlineNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountOnlineNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameAccountOnlineNotification::MergeFrom(const GameAccountOnlineNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_game_account_id()) {
+      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+    }
+    if (from.has_host()) {
+      mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host());
+    }
+    if (from.has_session_id()) {
+      set_session_id(from.session_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameAccountOnlineNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameAccountOnlineNotification::CopyFrom(const GameAccountOnlineNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameAccountOnlineNotification::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_game_account_id()) {
+    if (!this->game_account_id().IsInitialized()) return false;
+  }
+  if (has_host()) {
+    if (!this->host().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GameAccountOnlineNotification::Swap(GameAccountOnlineNotification* other) {
+  if (other != this) {
+    std::swap(game_account_id_, other->game_account_id_);
+    std::swap(host_, other->host_);
+    std::swap(session_id_, other->session_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameAccountOnlineNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameAccountOnlineNotification_descriptor_;
+  metadata.reflection = GameAccountOnlineNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GameAccountOfflineNotification::kGameAccountIdFieldNumber;
+const int GameAccountOfflineNotification::kHostFieldNumber;
+const int GameAccountOfflineNotification::kSessionIdFieldNumber;
+#endif  // !_MSC_VER
+
+GameAccountOfflineNotification::GameAccountOfflineNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification)
+}
+
+void GameAccountOfflineNotification::InitAsDefaultInstance() {
+  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+}
+
+GameAccountOfflineNotification::GameAccountOfflineNotification(const GameAccountOfflineNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification)
+}
+
+void GameAccountOfflineNotification::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  game_account_id_ = NULL;
+  host_ = NULL;
+  session_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GameAccountOfflineNotification::~GameAccountOfflineNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification)
+  SharedDtor();
+}
+
+void GameAccountOfflineNotification::SharedDtor() {
+  if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete session_id_;
+  }
+  if (this != default_instance_) {
+    delete game_account_id_;
+    delete host_;
+  }
+}
+
+void GameAccountOfflineNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GameAccountOfflineNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameAccountOfflineNotification_descriptor_;
+}
+
+const GameAccountOfflineNotification& GameAccountOfflineNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GameAccountOfflineNotification* GameAccountOfflineNotification::default_instance_ = NULL;
+
+GameAccountOfflineNotification* GameAccountOfflineNotification::New() const {
+  return new GameAccountOfflineNotification;
+}
+
+void GameAccountOfflineNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_game_account_id()) {
+      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_host()) {
+      if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+    }
+    if (has_session_id()) {
+      if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        session_id_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GameAccountOfflineNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.EntityId game_account_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_host;
+        break;
+      }
+
+      // optional .bgs.protocol.ProcessId host = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_host:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_host()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_session_id;
+        break;
+      }
+
+      // optional string session_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_session_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_session_id()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->session_id().data(), this->session_id().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "session_id");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification)
+  return false;
+#undef DO_
+}
+
+void GameAccountOfflineNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification)
+  // required .bgs.protocol.EntityId game_account_id = 1;
+  if (has_game_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->game_account_id(), output);
+  }
+
+  // optional .bgs.protocol.ProcessId host = 2;
+  if (has_host()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->host(), output);
+  }
+
+  // optional string session_id = 3;
+  if (has_session_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->session_id().data(), this->session_id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "session_id");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->session_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification)
+}
+
+::google::protobuf::uint8* GameAccountOfflineNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification)
+  // required .bgs.protocol.EntityId game_account_id = 1;
+  if (has_game_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->game_account_id(), target);
+  }
+
+  // optional .bgs.protocol.ProcessId host = 2;
+  if (has_host()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->host(), target);
+  }
+
+  // optional string session_id = 3;
+  if (has_session_id()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->session_id().data(), this->session_id().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "session_id");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->session_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification)
+  return target;
+}
+
+int GameAccountOfflineNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.EntityId game_account_id = 1;
+    if (has_game_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_id());
+    }
+
+    // optional .bgs.protocol.ProcessId host = 2;
+    if (has_host()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->host());
+    }
+
+    // optional string session_id = 3;
+    if (has_session_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->session_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GameAccountOfflineNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GameAccountOfflineNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GameAccountOfflineNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GameAccountOfflineNotification::MergeFrom(const GameAccountOfflineNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_game_account_id()) {
+      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+    }
+    if (from.has_host()) {
+      mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host());
+    }
+    if (from.has_session_id()) {
+      set_session_id(from.session_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GameAccountOfflineNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GameAccountOfflineNotification::CopyFrom(const GameAccountOfflineNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GameAccountOfflineNotification::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_game_account_id()) {
+    if (!this->game_account_id().IsInitialized()) return false;
+  }
+  if (has_host()) {
+    if (!this->host().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GameAccountOfflineNotification::Swap(GameAccountOfflineNotification* other) {
+  if (other != this) {
+    std::swap(game_account_id_, other->game_account_id_);
+    std::swap(host_, other->host_);
+    std::swap(session_id_, other->session_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GameAccountOfflineNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GameAccountOfflineNotification_descriptor_;
+  metadata.reflection = GameAccountOfflineNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetAchievementsFileRequest::kHostFieldNumber;
+#endif  // !_MSC_VER
+
+GetAchievementsFileRequest::GetAchievementsFileRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest)
+}
+
+void GetAchievementsFileRequest::InitAsDefaultInstance() {
+  host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+}
+
+GetAchievementsFileRequest::GetAchievementsFileRequest(const GetAchievementsFileRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest)
+}
+
+void GetAchievementsFileRequest::SharedCtor() {
+  _cached_size_ = 0;
+  host_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetAchievementsFileRequest::~GetAchievementsFileRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest)
+  SharedDtor();
+}
+
+void GetAchievementsFileRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete host_;
+  }
+}
+
+void GetAchievementsFileRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetAchievementsFileRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetAchievementsFileRequest_descriptor_;
+}
+
+const GetAchievementsFileRequest& GetAchievementsFileRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetAchievementsFileRequest* GetAchievementsFileRequest::default_instance_ = NULL;
+
+GetAchievementsFileRequest* GetAchievementsFileRequest::New() const {
+  return new GetAchievementsFileRequest;
+}
+
+void GetAchievementsFileRequest::Clear() {
+  if (has_host()) {
+    if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetAchievementsFileRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.ProcessId host = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_host()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest)
+  return false;
+#undef DO_
+}
+
+void GetAchievementsFileRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest)
+  // optional .bgs.protocol.ProcessId host = 1;
+  if (has_host()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->host(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest)
+}
+
+::google::protobuf::uint8* GetAchievementsFileRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest)
+  // optional .bgs.protocol.ProcessId host = 1;
+  if (has_host()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->host(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest)
+  return target;
+}
+
+int GetAchievementsFileRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.ProcessId host = 1;
+    if (has_host()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->host());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetAchievementsFileRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetAchievementsFileRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetAchievementsFileRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetAchievementsFileRequest::MergeFrom(const GetAchievementsFileRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_host()) {
+      mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetAchievementsFileRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetAchievementsFileRequest::CopyFrom(const GetAchievementsFileRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetAchievementsFileRequest::IsInitialized() const {
+
+  if (has_host()) {
+    if (!this->host().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetAchievementsFileRequest::Swap(GetAchievementsFileRequest* other) {
+  if (other != this) {
+    std::swap(host_, other->host_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetAchievementsFileRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetAchievementsFileRequest_descriptor_;
+  metadata.reflection = GetAchievementsFileRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetAchievementsFileResponse::kContentHandleFieldNumber;
+#endif  // !_MSC_VER
+
+GetAchievementsFileResponse::GetAchievementsFileResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse)
+}
+
+void GetAchievementsFileResponse::InitAsDefaultInstance() {
+  content_handle_ = const_cast< ::bgs::protocol::ContentHandle*>(&::bgs::protocol::ContentHandle::default_instance());
+}
+
+GetAchievementsFileResponse::GetAchievementsFileResponse(const GetAchievementsFileResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse)
+}
+
+void GetAchievementsFileResponse::SharedCtor() {
+  _cached_size_ = 0;
+  content_handle_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetAchievementsFileResponse::~GetAchievementsFileResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse)
+  SharedDtor();
+}
+
+void GetAchievementsFileResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete content_handle_;
+  }
+}
+
+void GetAchievementsFileResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetAchievementsFileResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetAchievementsFileResponse_descriptor_;
+}
+
+const GetAchievementsFileResponse& GetAchievementsFileResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetAchievementsFileResponse* GetAchievementsFileResponse::default_instance_ = NULL;
+
+GetAchievementsFileResponse* GetAchievementsFileResponse::New() const {
+  return new GetAchievementsFileResponse;
+}
+
+void GetAchievementsFileResponse::Clear() {
+  if (has_content_handle()) {
+    if (content_handle_ != NULL) content_handle_->::bgs::protocol::ContentHandle::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetAchievementsFileResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.ContentHandle content_handle = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_content_handle()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse)
+  return false;
+#undef DO_
+}
+
+void GetAchievementsFileResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse)
+  // optional .bgs.protocol.ContentHandle content_handle = 1;
+  if (has_content_handle()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->content_handle(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse)
+}
+
+::google::protobuf::uint8* GetAchievementsFileResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse)
+  // optional .bgs.protocol.ContentHandle content_handle = 1;
+  if (has_content_handle()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->content_handle(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse)
+  return target;
+}
+
+int GetAchievementsFileResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.ContentHandle content_handle = 1;
+    if (has_content_handle()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->content_handle());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetAchievementsFileResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetAchievementsFileResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetAchievementsFileResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetAchievementsFileResponse::MergeFrom(const GetAchievementsFileResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_content_handle()) {
+      mutable_content_handle()->::bgs::protocol::ContentHandle::MergeFrom(from.content_handle());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetAchievementsFileResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetAchievementsFileResponse::CopyFrom(const GetAchievementsFileResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetAchievementsFileResponse::IsInitialized() const {
+
+  if (has_content_handle()) {
+    if (!this->content_handle().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetAchievementsFileResponse::Swap(GetAchievementsFileResponse* other) {
+  if (other != this) {
+    std::swap(content_handle_, other->content_handle_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetAchievementsFileResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetAchievementsFileResponse_descriptor_;
+  metadata.reflection = GetAchievementsFileResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetAllValuesForAttributeRequest::kAttributeKeyFieldNumber;
+const int GetAllValuesForAttributeRequest::kAgentIdFieldNumber;
+const int GetAllValuesForAttributeRequest::kProgramFieldNumber;
+#endif  // !_MSC_VER
+
+GetAllValuesForAttributeRequest::GetAllValuesForAttributeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest)
+}
+
+void GetAllValuesForAttributeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+GetAllValuesForAttributeRequest::GetAllValuesForAttributeRequest(const GetAllValuesForAttributeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest)
+}
+
+void GetAllValuesForAttributeRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  attribute_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  agent_id_ = NULL;
+  program_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetAllValuesForAttributeRequest::~GetAllValuesForAttributeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest)
+  SharedDtor();
+}
+
+void GetAllValuesForAttributeRequest::SharedDtor() {
+  if (attribute_key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete attribute_key_;
+  }
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void GetAllValuesForAttributeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetAllValuesForAttributeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetAllValuesForAttributeRequest_descriptor_;
+}
+
+const GetAllValuesForAttributeRequest& GetAllValuesForAttributeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetAllValuesForAttributeRequest* GetAllValuesForAttributeRequest::default_instance_ = NULL;
+
+GetAllValuesForAttributeRequest* GetAllValuesForAttributeRequest::New() const {
+  return new GetAllValuesForAttributeRequest;
+}
+
+void GetAllValuesForAttributeRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_attribute_key()) {
+      if (attribute_key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        attribute_key_->clear();
+      }
+    }
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    program_ = 0u;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetAllValuesForAttributeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string attribute_key = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_attribute_key()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->attribute_key().data(), this->attribute_key().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "attribute_key");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_agent_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId agent_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_agent_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(45)) goto parse_program;
+        break;
+      }
+
+      // optional fixed32 program = 5;
+      case 5: {
+        if (tag == 45) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest)
+  return false;
+#undef DO_
+}
+
+void GetAllValuesForAttributeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest)
+  // optional string attribute_key = 1;
+  if (has_attribute_key()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->attribute_key().data(), this->attribute_key().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "attribute_key");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->attribute_key(), output);
+  }
+
+  // optional .bgs.protocol.EntityId agent_id = 2;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->agent_id(), output);
+  }
+
+  // optional fixed32 program = 5;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->program(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest)
+}
+
+::google::protobuf::uint8* GetAllValuesForAttributeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest)
+  // optional string attribute_key = 1;
+  if (has_attribute_key()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->attribute_key().data(), this->attribute_key().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "attribute_key");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->attribute_key(), target);
+  }
+
+  // optional .bgs.protocol.EntityId agent_id = 2;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->agent_id(), target);
+  }
+
+  // optional fixed32 program = 5;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->program(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest)
+  return target;
+}
+
+int GetAllValuesForAttributeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string attribute_key = 1;
+    if (has_attribute_key()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->attribute_key());
+    }
+
+    // optional .bgs.protocol.EntityId agent_id = 2;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional fixed32 program = 5;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetAllValuesForAttributeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetAllValuesForAttributeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetAllValuesForAttributeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetAllValuesForAttributeRequest::MergeFrom(const GetAllValuesForAttributeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_attribute_key()) {
+      set_attribute_key(from.attribute_key());
+    }
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetAllValuesForAttributeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetAllValuesForAttributeRequest::CopyFrom(const GetAllValuesForAttributeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetAllValuesForAttributeRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GetAllValuesForAttributeRequest::Swap(GetAllValuesForAttributeRequest* other) {
+  if (other != this) {
+    std::swap(attribute_key_, other->attribute_key_);
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(program_, other->program_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetAllValuesForAttributeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetAllValuesForAttributeRequest_descriptor_;
+  metadata.reflection = GetAllValuesForAttributeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GetAllValuesForAttributeResponse::kAttributeValueFieldNumber;
+#endif  // !_MSC_VER
+
+GetAllValuesForAttributeResponse::GetAllValuesForAttributeResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse)
+}
+
+void GetAllValuesForAttributeResponse::InitAsDefaultInstance() {
+}
+
+GetAllValuesForAttributeResponse::GetAllValuesForAttributeResponse(const GetAllValuesForAttributeResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse)
+}
+
+void GetAllValuesForAttributeResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GetAllValuesForAttributeResponse::~GetAllValuesForAttributeResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse)
+  SharedDtor();
+}
+
+void GetAllValuesForAttributeResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void GetAllValuesForAttributeResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GetAllValuesForAttributeResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GetAllValuesForAttributeResponse_descriptor_;
+}
+
+const GetAllValuesForAttributeResponse& GetAllValuesForAttributeResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  return *default_instance_;
+}
+
+GetAllValuesForAttributeResponse* GetAllValuesForAttributeResponse::default_instance_ = NULL;
+
+GetAllValuesForAttributeResponse* GetAllValuesForAttributeResponse::New() const {
+  return new GetAllValuesForAttributeResponse;
+}
+
+void GetAllValuesForAttributeResponse::Clear() {
+  attribute_value_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GetAllValuesForAttributeResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.Variant attribute_value = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_attribute_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute_value()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_attribute_value;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse)
+  return false;
+#undef DO_
+}
+
+void GetAllValuesForAttributeResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse)
+  // repeated .bgs.protocol.Variant attribute_value = 1;
+  for (int i = 0; i < this->attribute_value_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->attribute_value(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse)
+}
+
+::google::protobuf::uint8* GetAllValuesForAttributeResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse)
+  // repeated .bgs.protocol.Variant attribute_value = 1;
+  for (int i = 0; i < this->attribute_value_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->attribute_value(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse)
+  return target;
+}
+
+int GetAllValuesForAttributeResponse::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.Variant attribute_value = 1;
+  total_size += 1 * this->attribute_value_size();
+  for (int i = 0; i < this->attribute_value_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute_value(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GetAllValuesForAttributeResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GetAllValuesForAttributeResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GetAllValuesForAttributeResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GetAllValuesForAttributeResponse::MergeFrom(const GetAllValuesForAttributeResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_value_.MergeFrom(from.attribute_value_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GetAllValuesForAttributeResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GetAllValuesForAttributeResponse::CopyFrom(const GetAllValuesForAttributeResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GetAllValuesForAttributeResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute_value())) return false;
+  return true;
+}
+
+void GetAllValuesForAttributeResponse::Swap(GetAllValuesForAttributeResponse* other) {
+  if (other != this) {
+    attribute_value_.Swap(&other->attribute_value_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GetAllValuesForAttributeResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GetAllValuesForAttributeResponse_descriptor_;
+  metadata.reflection = GetAllValuesForAttributeResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* GameUtilitiesService::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GameUtilitiesService_descriptor_;
+}
+
+void GameUtilitiesService::ProcessClientRequest(::bgs::protocol::game_utilities::v1::ClientRequest const* request, std::function<void(::bgs::protocol::game_utilities::v1::ClientResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method GameUtilitiesService.ProcessClientRequest(bgs.protocol.game_utilities.v1.ClientRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::game_utilities::v1::ClientResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void GameUtilitiesService::PresenceChannelCreated(::bgs::protocol::game_utilities::v1::PresenceChannelCreatedRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method GameUtilitiesService.PresenceChannelCreated(bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 2, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void GameUtilitiesService::GetPlayerVariables(::bgs::protocol::game_utilities::v1::GetPlayerVariablesRequest const* request, std::function<void(::bgs::protocol::game_utilities::v1::GetPlayerVariablesResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method GameUtilitiesService.GetPlayerVariables(bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 3, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::game_utilities::v1::GetPlayerVariablesResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void GameUtilitiesService::ProcessServerRequest(::bgs::protocol::game_utilities::v1::ServerRequest const* request, std::function<void(::bgs::protocol::game_utilities::v1::ServerResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method GameUtilitiesService.ProcessServerRequest(bgs.protocol.game_utilities.v1.ServerRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 6, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::game_utilities::v1::ServerResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void GameUtilitiesService::OnGameAccountOnline(::bgs::protocol::game_utilities::v1::GameAccountOnlineNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method GameUtilitiesService.OnGameAccountOnline(bgs.protocol.game_utilities.v1.GameAccountOnlineNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 7, request);
+}
+
+void GameUtilitiesService::OnGameAccountOffline(::bgs::protocol::game_utilities::v1::GameAccountOfflineNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method GameUtilitiesService.OnGameAccountOffline(bgs.protocol.game_utilities.v1.GameAccountOfflineNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 8, request);
+}
+
+void GameUtilitiesService::GetAchievementsFile(::bgs::protocol::game_utilities::v1::GetAchievementsFileRequest const* request, std::function<void(::bgs::protocol::game_utilities::v1::GetAchievementsFileResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method GameUtilitiesService.GetAchievementsFile(bgs.protocol.game_utilities.v1.GetAchievementsFileRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 9, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::game_utilities::v1::GetAchievementsFileResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void GameUtilitiesService::GetAllValuesForAttribute(::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeRequest const* request, std::function<void(::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method GameUtilitiesService.GetAllValuesForAttribute(bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 10, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void GameUtilitiesService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::game_utilities::v1::ClientRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for GameUtilitiesService.ProcessClientRequest server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::game_utilities::v1::ClientResponse response;
+      uint32 status = HandleProcessClientRequest(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method GameUtilitiesService.ProcessClientRequest(bgs.protocol.game_utilities.v1.ClientRequest{ %s }) returned bgs.protocol.game_utilities.v1.ClientResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 1, token, &response);
+      else
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    case 2: {
+      ::bgs::protocol::game_utilities::v1::PresenceChannelCreatedRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for GameUtilitiesService.PresenceChannelCreated server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandlePresenceChannelCreated(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method GameUtilitiesService.PresenceChannelCreated(bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 2, token, &response);
+      else
+        SendResponse(service_hash_, 2, token, status);
+      break;
+    }
+    case 3: {
+      ::bgs::protocol::game_utilities::v1::GetPlayerVariablesRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for GameUtilitiesService.GetPlayerVariables server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::game_utilities::v1::GetPlayerVariablesResponse response;
+      uint32 status = HandleGetPlayerVariables(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method GameUtilitiesService.GetPlayerVariables(bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest{ %s }) returned bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 3, token, &response);
+      else
+        SendResponse(service_hash_, 3, token, status);
+      break;
+    }
+    case 6: {
+      ::bgs::protocol::game_utilities::v1::ServerRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for GameUtilitiesService.ProcessServerRequest server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 6, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::game_utilities::v1::ServerResponse response;
+      uint32 status = HandleProcessServerRequest(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method GameUtilitiesService.ProcessServerRequest(bgs.protocol.game_utilities.v1.ServerRequest{ %s }) returned bgs.protocol.game_utilities.v1.ServerResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 6, token, &response);
+      else
+        SendResponse(service_hash_, 6, token, status);
+      break;
+    }
+    case 7: {
+      ::bgs::protocol::game_utilities::v1::GameAccountOnlineNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for GameUtilitiesService.OnGameAccountOnline server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnGameAccountOnline(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method GameUtilitiesService.OnGameAccountOnline(bgs.protocol.game_utilities.v1.GameAccountOnlineNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 7, token, status);
+      break;
+    }
+    case 8: {
+      ::bgs::protocol::game_utilities::v1::GameAccountOfflineNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for GameUtilitiesService.OnGameAccountOffline server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 8, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnGameAccountOffline(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method GameUtilitiesService.OnGameAccountOffline(bgs.protocol.game_utilities.v1.GameAccountOfflineNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 8, token, status);
+      break;
+    }
+    case 9: {
+      ::bgs::protocol::game_utilities::v1::GetAchievementsFileRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for GameUtilitiesService.GetAchievementsFile server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 9, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::game_utilities::v1::GetAchievementsFileResponse response;
+      uint32 status = HandleGetAchievementsFile(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method GameUtilitiesService.GetAchievementsFile(bgs.protocol.game_utilities.v1.GetAchievementsFileRequest{ %s }) returned bgs.protocol.game_utilities.v1.GetAchievementsFileResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 9, token, &response);
+      else
+        SendResponse(service_hash_, 9, token, status);
+      break;
+    }
+    case 10: {
+      ::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for GameUtilitiesService.GetAllValuesForAttribute server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 10, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeResponse response;
+      uint32 status = HandleGetAllValuesForAttribute(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method GameUtilitiesService.GetAllValuesForAttribute(bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest{ %s }) returned bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 10, token, &response);
+      else
+        SendResponse(service_hash_, 10, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 GameUtilitiesService::HandleProcessClientRequest(::bgs::protocol::game_utilities::v1::ClientRequest const* request, ::bgs::protocol::game_utilities::v1::ClientResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method GameUtilitiesService.ProcessClientRequest({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 GameUtilitiesService::HandlePresenceChannelCreated(::bgs::protocol::game_utilities::v1::PresenceChannelCreatedRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method GameUtilitiesService.PresenceChannelCreated({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 GameUtilitiesService::HandleGetPlayerVariables(::bgs::protocol::game_utilities::v1::GetPlayerVariablesRequest const* request, ::bgs::protocol::game_utilities::v1::GetPlayerVariablesResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method GameUtilitiesService.GetPlayerVariables({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 GameUtilitiesService::HandleProcessServerRequest(::bgs::protocol::game_utilities::v1::ServerRequest const* request, ::bgs::protocol::game_utilities::v1::ServerResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method GameUtilitiesService.ProcessServerRequest({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 GameUtilitiesService::HandleOnGameAccountOnline(::bgs::protocol::game_utilities::v1::GameAccountOnlineNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method GameUtilitiesService.OnGameAccountOnline({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 GameUtilitiesService::HandleOnGameAccountOffline(::bgs::protocol::game_utilities::v1::GameAccountOfflineNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method GameUtilitiesService.OnGameAccountOffline({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 GameUtilitiesService::HandleGetAchievementsFile(::bgs::protocol::game_utilities::v1::GetAchievementsFileRequest const* request, ::bgs::protocol::game_utilities::v1::GetAchievementsFileResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method GameUtilitiesService.GetAchievementsFile({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 GameUtilitiesService::HandleGetAllValuesForAttribute(::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeRequest const* request, ::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method GameUtilitiesService.GetAllValuesForAttribute({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace game_utilities
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/game_utilities_service.pb.h b/src/server/proto/Client/game_utilities_service.pb.h
new file mode 100644
index 00000000000..511e6ad79b4
--- /dev/null
+++ b/src/server/proto/Client/game_utilities_service.pb.h
@@ -0,0 +1,2654 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: game_utilities_service.proto
+
+#ifndef PROTOBUF_game_5futilities_5fservice_2eproto__INCLUDED
+#define PROTOBUF_game_5futilities_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 "attribute_types.pb.h"
+#include "content_handle_types.pb.h"
+#include "entity_types.pb.h"
+#include "game_utilities_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 game_utilities {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+void protobuf_AssignDesc_game_5futilities_5fservice_2eproto();
+void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto();
+
+class ClientRequest;
+class ClientResponse;
+class ServerRequest;
+class ServerResponse;
+class PresenceChannelCreatedRequest;
+class GetPlayerVariablesRequest;
+class GetPlayerVariablesResponse;
+class GameAccountOnlineNotification;
+class GameAccountOfflineNotification;
+class GetAchievementsFileRequest;
+class GetAchievementsFileResponse;
+class GetAllValuesForAttributeRequest;
+class GetAllValuesForAttributeResponse;
+
+// ===================================================================
+
+class TC_SHARED_API ClientRequest : public ::google::protobuf::Message {
+ public:
+  ClientRequest();
+  virtual ~ClientRequest();
+
+  ClientRequest(const ClientRequest& from);
+
+  inline ClientRequest& operator=(const ClientRequest& 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 ClientRequest& default_instance();
+
+  void Swap(ClientRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClientRequest& from);
+  void MergeFrom(const ClientRequest& 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.Attribute attribute = 1;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 1;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
+  // optional .bgs.protocol.ProcessId host = 2;
+  inline bool has_host() const;
+  inline void clear_host();
+  static const int kHostFieldNumber = 2;
+  inline const ::bgs::protocol::ProcessId& host() const;
+  inline ::bgs::protocol::ProcessId* mutable_host();
+  inline ::bgs::protocol::ProcessId* release_host();
+  inline void set_allocated_host(::bgs::protocol::ProcessId* host);
+
+  // optional .bgs.protocol.EntityId account_id = 3;
+  inline bool has_account_id() const;
+  inline void clear_account_id();
+  static const int kAccountIdFieldNumber = 3;
+  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);
+
+  // optional .bgs.protocol.EntityId game_account_id = 4;
+  inline bool has_game_account_id() const;
+  inline void clear_game_account_id();
+  static const int kGameAccountIdFieldNumber = 4;
+  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);
+
+  // optional fixed32 program = 5;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 5;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // optional .bgs.protocol.game_utilities.v1.ClientInfo client_info = 6;
+  inline bool has_client_info() const;
+  inline void clear_client_info();
+  static const int kClientInfoFieldNumber = 6;
+  inline const ::bgs::protocol::game_utilities::v1::ClientInfo& client_info() const;
+  inline ::bgs::protocol::game_utilities::v1::ClientInfo* mutable_client_info();
+  inline ::bgs::protocol::game_utilities::v1::ClientInfo* release_client_info();
+  inline void set_allocated_client_info(::bgs::protocol::game_utilities::v1::ClientInfo* client_info);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.ClientRequest)
+ private:
+  inline void set_has_host();
+  inline void clear_has_host();
+  inline void set_has_account_id();
+  inline void clear_has_account_id();
+  inline void set_has_game_account_id();
+  inline void clear_has_game_account_id();
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_client_info();
+  inline void clear_has_client_info();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
+  ::bgs::protocol::ProcessId* host_;
+  ::bgs::protocol::EntityId* account_id_;
+  ::bgs::protocol::EntityId* game_account_id_;
+  ::bgs::protocol::game_utilities::v1::ClientInfo* client_info_;
+  ::google::protobuf::uint32 program_;
+  friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ClientResponse : public ::google::protobuf::Message {
+ public:
+  ClientResponse();
+  virtual ~ClientResponse();
+
+  ClientResponse(const ClientResponse& from);
+
+  inline ClientResponse& operator=(const ClientResponse& 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 ClientResponse& default_instance();
+
+  void Swap(ClientResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClientResponse& from);
+  void MergeFrom(const ClientResponse& 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.Attribute attribute = 1;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 1;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.ClientResponse)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
+  friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ServerRequest : public ::google::protobuf::Message {
+ public:
+  ServerRequest();
+  virtual ~ServerRequest();
+
+  ServerRequest(const ServerRequest& from);
+
+  inline ServerRequest& operator=(const ServerRequest& 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 ServerRequest& default_instance();
+
+  void Swap(ServerRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ServerRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ServerRequest& from);
+  void MergeFrom(const ServerRequest& 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.Attribute attribute = 1;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 1;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
+  // required fixed32 program = 2;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 2;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // optional .bgs.protocol.ProcessId host = 3;
+  inline bool has_host() const;
+  inline void clear_host();
+  static const int kHostFieldNumber = 3;
+  inline const ::bgs::protocol::ProcessId& host() const;
+  inline ::bgs::protocol::ProcessId* mutable_host();
+  inline ::bgs::protocol::ProcessId* release_host();
+  inline void set_allocated_host(::bgs::protocol::ProcessId* host);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.ServerRequest)
+ private:
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_host();
+  inline void clear_has_host();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
+  ::bgs::protocol::ProcessId* host_;
+  ::google::protobuf::uint32 program_;
+  friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ServerRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ServerResponse : public ::google::protobuf::Message {
+ public:
+  ServerResponse();
+  virtual ~ServerResponse();
+
+  ServerResponse(const ServerResponse& from);
+
+  inline ServerResponse& operator=(const ServerResponse& 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 ServerResponse& default_instance();
+
+  void Swap(ServerResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  ServerResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ServerResponse& from);
+  void MergeFrom(const ServerResponse& 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.Attribute attribute = 1;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 1;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.ServerResponse)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
+  friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ServerResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API PresenceChannelCreatedRequest : public ::google::protobuf::Message {
+ public:
+  PresenceChannelCreatedRequest();
+  virtual ~PresenceChannelCreatedRequest();
+
+  PresenceChannelCreatedRequest(const PresenceChannelCreatedRequest& from);
+
+  inline PresenceChannelCreatedRequest& operator=(const PresenceChannelCreatedRequest& 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 PresenceChannelCreatedRequest& default_instance();
+
+  void Swap(PresenceChannelCreatedRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  PresenceChannelCreatedRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const PresenceChannelCreatedRequest& from);
+  void MergeFrom(const PresenceChannelCreatedRequest& 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 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& id() const;
+  inline ::bgs::protocol::EntityId* mutable_id();
+  inline ::bgs::protocol::EntityId* release_id();
+  inline void set_allocated_id(::bgs::protocol::EntityId* id);
+
+  // optional .bgs.protocol.EntityId game_account_id = 3;
+  inline bool has_game_account_id() const;
+  inline void clear_game_account_id();
+  static const int kGameAccountIdFieldNumber = 3;
+  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);
+
+  // optional .bgs.protocol.EntityId account_id = 4;
+  inline bool has_account_id() const;
+  inline void clear_account_id();
+  static const int kAccountIdFieldNumber = 4;
+  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);
+
+  // optional .bgs.protocol.ProcessId host = 5;
+  inline bool has_host() const;
+  inline void clear_host();
+  static const int kHostFieldNumber = 5;
+  inline const ::bgs::protocol::ProcessId& host() const;
+  inline ::bgs::protocol::ProcessId* mutable_host();
+  inline ::bgs::protocol::ProcessId* release_host();
+  inline void set_allocated_host(::bgs::protocol::ProcessId* host);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_game_account_id();
+  inline void clear_has_game_account_id();
+  inline void set_has_account_id();
+  inline void clear_has_account_id();
+  inline void set_has_host();
+  inline void clear_has_host();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* id_;
+  ::bgs::protocol::EntityId* game_account_id_;
+  ::bgs::protocol::EntityId* account_id_;
+  ::bgs::protocol::ProcessId* host_;
+  friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static PresenceChannelCreatedRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetPlayerVariablesRequest : public ::google::protobuf::Message {
+ public:
+  GetPlayerVariablesRequest();
+  virtual ~GetPlayerVariablesRequest();
+
+  GetPlayerVariablesRequest(const GetPlayerVariablesRequest& from);
+
+  inline GetPlayerVariablesRequest& operator=(const GetPlayerVariablesRequest& 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 GetPlayerVariablesRequest& default_instance();
+
+  void Swap(GetPlayerVariablesRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetPlayerVariablesRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetPlayerVariablesRequest& from);
+  void MergeFrom(const GetPlayerVariablesRequest& 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.game_utilities.v1.PlayerVariables player_variables = 1;
+  inline int player_variables_size() const;
+  inline void clear_player_variables();
+  static const int kPlayerVariablesFieldNumber = 1;
+  inline const ::bgs::protocol::game_utilities::v1::PlayerVariables& player_variables(int index) const;
+  inline ::bgs::protocol::game_utilities::v1::PlayerVariables* mutable_player_variables(int index);
+  inline ::bgs::protocol::game_utilities::v1::PlayerVariables* add_player_variables();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables >&
+      player_variables() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables >*
+      mutable_player_variables();
+
+  // optional .bgs.protocol.ProcessId host = 2;
+  inline bool has_host() const;
+  inline void clear_host();
+  static const int kHostFieldNumber = 2;
+  inline const ::bgs::protocol::ProcessId& host() const;
+  inline ::bgs::protocol::ProcessId* mutable_host();
+  inline ::bgs::protocol::ProcessId* release_host();
+  inline void set_allocated_host(::bgs::protocol::ProcessId* host);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest)
+ private:
+  inline void set_has_host();
+  inline void clear_has_host();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables > player_variables_;
+  ::bgs::protocol::ProcessId* host_;
+  friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetPlayerVariablesRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetPlayerVariablesResponse : public ::google::protobuf::Message {
+ public:
+  GetPlayerVariablesResponse();
+  virtual ~GetPlayerVariablesResponse();
+
+  GetPlayerVariablesResponse(const GetPlayerVariablesResponse& from);
+
+  inline GetPlayerVariablesResponse& operator=(const GetPlayerVariablesResponse& 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 GetPlayerVariablesResponse& default_instance();
+
+  void Swap(GetPlayerVariablesResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetPlayerVariablesResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetPlayerVariablesResponse& from);
+  void MergeFrom(const GetPlayerVariablesResponse& 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.game_utilities.v1.PlayerVariables player_variables = 1;
+  inline int player_variables_size() const;
+  inline void clear_player_variables();
+  static const int kPlayerVariablesFieldNumber = 1;
+  inline const ::bgs::protocol::game_utilities::v1::PlayerVariables& player_variables(int index) const;
+  inline ::bgs::protocol::game_utilities::v1::PlayerVariables* mutable_player_variables(int index);
+  inline ::bgs::protocol::game_utilities::v1::PlayerVariables* add_player_variables();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables >&
+      player_variables() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables >*
+      mutable_player_variables();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables > player_variables_;
+  friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetPlayerVariablesResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameAccountOnlineNotification : public ::google::protobuf::Message {
+ public:
+  GameAccountOnlineNotification();
+  virtual ~GameAccountOnlineNotification();
+
+  GameAccountOnlineNotification(const GameAccountOnlineNotification& from);
+
+  inline GameAccountOnlineNotification& operator=(const GameAccountOnlineNotification& 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 GameAccountOnlineNotification& default_instance();
+
+  void Swap(GameAccountOnlineNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  GameAccountOnlineNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameAccountOnlineNotification& from);
+  void MergeFrom(const GameAccountOnlineNotification& 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);
+
+  // optional .bgs.protocol.ProcessId host = 2;
+  inline bool has_host() const;
+  inline void clear_host();
+  static const int kHostFieldNumber = 2;
+  inline const ::bgs::protocol::ProcessId& host() const;
+  inline ::bgs::protocol::ProcessId* mutable_host();
+  inline ::bgs::protocol::ProcessId* release_host();
+  inline void set_allocated_host(::bgs::protocol::ProcessId* host);
+
+  // optional string session_id = 3;
+  inline bool has_session_id() const;
+  inline void clear_session_id();
+  static const int kSessionIdFieldNumber = 3;
+  inline const ::std::string& session_id() const;
+  inline void set_session_id(const ::std::string& value);
+  inline void set_session_id(const char* value);
+  inline void set_session_id(const char* value, size_t size);
+  inline ::std::string* mutable_session_id();
+  inline ::std::string* release_session_id();
+  inline void set_allocated_session_id(::std::string* session_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification)
+ private:
+  inline void set_has_game_account_id();
+  inline void clear_has_game_account_id();
+  inline void set_has_host();
+  inline void clear_has_host();
+  inline void set_has_session_id();
+  inline void clear_has_session_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* game_account_id_;
+  ::bgs::protocol::ProcessId* host_;
+  ::std::string* session_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameAccountOnlineNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GameAccountOfflineNotification : public ::google::protobuf::Message {
+ public:
+  GameAccountOfflineNotification();
+  virtual ~GameAccountOfflineNotification();
+
+  GameAccountOfflineNotification(const GameAccountOfflineNotification& from);
+
+  inline GameAccountOfflineNotification& operator=(const GameAccountOfflineNotification& 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 GameAccountOfflineNotification& default_instance();
+
+  void Swap(GameAccountOfflineNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  GameAccountOfflineNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GameAccountOfflineNotification& from);
+  void MergeFrom(const GameAccountOfflineNotification& 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);
+
+  // optional .bgs.protocol.ProcessId host = 2;
+  inline bool has_host() const;
+  inline void clear_host();
+  static const int kHostFieldNumber = 2;
+  inline const ::bgs::protocol::ProcessId& host() const;
+  inline ::bgs::protocol::ProcessId* mutable_host();
+  inline ::bgs::protocol::ProcessId* release_host();
+  inline void set_allocated_host(::bgs::protocol::ProcessId* host);
+
+  // optional string session_id = 3;
+  inline bool has_session_id() const;
+  inline void clear_session_id();
+  static const int kSessionIdFieldNumber = 3;
+  inline const ::std::string& session_id() const;
+  inline void set_session_id(const ::std::string& value);
+  inline void set_session_id(const char* value);
+  inline void set_session_id(const char* value, size_t size);
+  inline ::std::string* mutable_session_id();
+  inline ::std::string* release_session_id();
+  inline void set_allocated_session_id(::std::string* session_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification)
+ private:
+  inline void set_has_game_account_id();
+  inline void clear_has_game_account_id();
+  inline void set_has_host();
+  inline void clear_has_host();
+  inline void set_has_session_id();
+  inline void clear_has_session_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* game_account_id_;
+  ::bgs::protocol::ProcessId* host_;
+  ::std::string* session_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GameAccountOfflineNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetAchievementsFileRequest : public ::google::protobuf::Message {
+ public:
+  GetAchievementsFileRequest();
+  virtual ~GetAchievementsFileRequest();
+
+  GetAchievementsFileRequest(const GetAchievementsFileRequest& from);
+
+  inline GetAchievementsFileRequest& operator=(const GetAchievementsFileRequest& 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 GetAchievementsFileRequest& default_instance();
+
+  void Swap(GetAchievementsFileRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetAchievementsFileRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetAchievementsFileRequest& from);
+  void MergeFrom(const GetAchievementsFileRequest& 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.ProcessId host = 1;
+  inline bool has_host() const;
+  inline void clear_host();
+  static const int kHostFieldNumber = 1;
+  inline const ::bgs::protocol::ProcessId& host() const;
+  inline ::bgs::protocol::ProcessId* mutable_host();
+  inline ::bgs::protocol::ProcessId* release_host();
+  inline void set_allocated_host(::bgs::protocol::ProcessId* host);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest)
+ private:
+  inline void set_has_host();
+  inline void clear_has_host();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::ProcessId* host_;
+  friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetAchievementsFileRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetAchievementsFileResponse : public ::google::protobuf::Message {
+ public:
+  GetAchievementsFileResponse();
+  virtual ~GetAchievementsFileResponse();
+
+  GetAchievementsFileResponse(const GetAchievementsFileResponse& from);
+
+  inline GetAchievementsFileResponse& operator=(const GetAchievementsFileResponse& 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 GetAchievementsFileResponse& default_instance();
+
+  void Swap(GetAchievementsFileResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetAchievementsFileResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetAchievementsFileResponse& from);
+  void MergeFrom(const GetAchievementsFileResponse& 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.ContentHandle content_handle = 1;
+  inline bool has_content_handle() const;
+  inline void clear_content_handle();
+  static const int kContentHandleFieldNumber = 1;
+  inline const ::bgs::protocol::ContentHandle& content_handle() const;
+  inline ::bgs::protocol::ContentHandle* mutable_content_handle();
+  inline ::bgs::protocol::ContentHandle* release_content_handle();
+  inline void set_allocated_content_handle(::bgs::protocol::ContentHandle* content_handle);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse)
+ private:
+  inline void set_has_content_handle();
+  inline void clear_has_content_handle();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::ContentHandle* content_handle_;
+  friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetAchievementsFileResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetAllValuesForAttributeRequest : public ::google::protobuf::Message {
+ public:
+  GetAllValuesForAttributeRequest();
+  virtual ~GetAllValuesForAttributeRequest();
+
+  GetAllValuesForAttributeRequest(const GetAllValuesForAttributeRequest& from);
+
+  inline GetAllValuesForAttributeRequest& operator=(const GetAllValuesForAttributeRequest& 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 GetAllValuesForAttributeRequest& default_instance();
+
+  void Swap(GetAllValuesForAttributeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GetAllValuesForAttributeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetAllValuesForAttributeRequest& from);
+  void MergeFrom(const GetAllValuesForAttributeRequest& 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 attribute_key = 1;
+  inline bool has_attribute_key() const;
+  inline void clear_attribute_key();
+  static const int kAttributeKeyFieldNumber = 1;
+  inline const ::std::string& attribute_key() const;
+  inline void set_attribute_key(const ::std::string& value);
+  inline void set_attribute_key(const char* value);
+  inline void set_attribute_key(const char* value, size_t size);
+  inline ::std::string* mutable_attribute_key();
+  inline ::std::string* release_attribute_key();
+  inline void set_allocated_attribute_key(::std::string* attribute_key);
+
+  // optional .bgs.protocol.EntityId agent_id = 2;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // optional fixed32 program = 5;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 5;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest)
+ private:
+  inline void set_has_attribute_key();
+  inline void clear_has_attribute_key();
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  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_;
+  ::std::string* attribute_key_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::uint32 program_;
+  friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetAllValuesForAttributeRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GetAllValuesForAttributeResponse : public ::google::protobuf::Message {
+ public:
+  GetAllValuesForAttributeResponse();
+  virtual ~GetAllValuesForAttributeResponse();
+
+  GetAllValuesForAttributeResponse(const GetAllValuesForAttributeResponse& from);
+
+  inline GetAllValuesForAttributeResponse& operator=(const GetAllValuesForAttributeResponse& 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 GetAllValuesForAttributeResponse& default_instance();
+
+  void Swap(GetAllValuesForAttributeResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  GetAllValuesForAttributeResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GetAllValuesForAttributeResponse& from);
+  void MergeFrom(const GetAllValuesForAttributeResponse& 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.Variant attribute_value = 1;
+  inline int attribute_value_size() const;
+  inline void clear_attribute_value();
+  static const int kAttributeValueFieldNumber = 1;
+  inline const ::bgs::protocol::Variant& attribute_value(int index) const;
+  inline ::bgs::protocol::Variant* mutable_attribute_value(int index);
+  inline ::bgs::protocol::Variant* add_attribute_value();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Variant >&
+      attribute_value() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Variant >*
+      mutable_attribute_value();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Variant > attribute_value_;
+  friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_AssignDesc_game_5futilities_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_game_5futilities_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static GetAllValuesForAttributeResponse* default_instance_;
+};
+// ===================================================================
+
+class TC_SHARED_API GameUtilitiesService : public ServiceBase
+{
+ public:
+
+  template<typename HashSelector>
+  explicit GameUtilitiesService(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  typedef std::integral_constant<uint32, 0x3FC1274Du> OriginalHash;
+  typedef std::integral_constant<uint32, 0x51923A28u> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void ProcessClientRequest(::bgs::protocol::game_utilities::v1::ClientRequest const* request, std::function<void(::bgs::protocol::game_utilities::v1::ClientResponse const*)> responseCallback);
+  void PresenceChannelCreated(::bgs::protocol::game_utilities::v1::PresenceChannelCreatedRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void GetPlayerVariables(::bgs::protocol::game_utilities::v1::GetPlayerVariablesRequest const* request, std::function<void(::bgs::protocol::game_utilities::v1::GetPlayerVariablesResponse const*)> responseCallback);
+  void ProcessServerRequest(::bgs::protocol::game_utilities::v1::ServerRequest const* request, std::function<void(::bgs::protocol::game_utilities::v1::ServerResponse const*)> responseCallback);
+  void OnGameAccountOnline(::bgs::protocol::game_utilities::v1::GameAccountOnlineNotification const* request);
+  void OnGameAccountOffline(::bgs::protocol::game_utilities::v1::GameAccountOfflineNotification const* request);
+  void GetAchievementsFile(::bgs::protocol::game_utilities::v1::GetAchievementsFileRequest const* request, std::function<void(::bgs::protocol::game_utilities::v1::GetAchievementsFileResponse const*)> responseCallback);
+  void GetAllValuesForAttribute(::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeRequest const* request, std::function<void(::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeResponse const*)> responseCallback);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleProcessClientRequest(::bgs::protocol::game_utilities::v1::ClientRequest const* request, ::bgs::protocol::game_utilities::v1::ClientResponse* response);
+  virtual uint32 HandlePresenceChannelCreated(::bgs::protocol::game_utilities::v1::PresenceChannelCreatedRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleGetPlayerVariables(::bgs::protocol::game_utilities::v1::GetPlayerVariablesRequest const* request, ::bgs::protocol::game_utilities::v1::GetPlayerVariablesResponse* response);
+  virtual uint32 HandleProcessServerRequest(::bgs::protocol::game_utilities::v1::ServerRequest const* request, ::bgs::protocol::game_utilities::v1::ServerResponse* response);
+  virtual uint32 HandleOnGameAccountOnline(::bgs::protocol::game_utilities::v1::GameAccountOnlineNotification const* request);
+  virtual uint32 HandleOnGameAccountOffline(::bgs::protocol::game_utilities::v1::GameAccountOfflineNotification const* request);
+  virtual uint32 HandleGetAchievementsFile(::bgs::protocol::game_utilities::v1::GetAchievementsFileRequest const* request, ::bgs::protocol::game_utilities::v1::GetAchievementsFileResponse* response);
+  virtual uint32 HandleGetAllValuesForAttribute(::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeRequest const* request, ::bgs::protocol::game_utilities::v1::GetAllValuesForAttributeResponse* response);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GameUtilitiesService);
+};
+
+// ===================================================================
+
+
+// ===================================================================
+
+// ClientRequest
+
+// repeated .bgs.protocol.Attribute attribute = 1;
+inline int ClientRequest::attribute_size() const {
+  return attribute_.size();
+}
+inline void ClientRequest::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::Attribute& ClientRequest::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientRequest.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::Attribute* ClientRequest::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ClientRequest.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* ClientRequest::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.game_utilities.v1.ClientRequest.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+ClientRequest::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.game_utilities.v1.ClientRequest.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+ClientRequest::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.game_utilities.v1.ClientRequest.attribute)
+  return &attribute_;
+}
+
+// optional .bgs.protocol.ProcessId host = 2;
+inline bool ClientRequest::has_host() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientRequest::set_has_host() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientRequest::clear_has_host() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientRequest::clear_host() {
+  if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+  clear_has_host();
+}
+inline const ::bgs::protocol::ProcessId& ClientRequest::host() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientRequest.host)
+  return host_ != NULL ? *host_ : *default_instance_->host_;
+}
+inline ::bgs::protocol::ProcessId* ClientRequest::mutable_host() {
+  set_has_host();
+  if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ClientRequest.host)
+  return host_;
+}
+inline ::bgs::protocol::ProcessId* ClientRequest::release_host() {
+  clear_has_host();
+  ::bgs::protocol::ProcessId* temp = host_;
+  host_ = NULL;
+  return temp;
+}
+inline void ClientRequest::set_allocated_host(::bgs::protocol::ProcessId* host) {
+  delete host_;
+  host_ = host;
+  if (host) {
+    set_has_host();
+  } else {
+    clear_has_host();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.ClientRequest.host)
+}
+
+// optional .bgs.protocol.EntityId account_id = 3;
+inline bool ClientRequest::has_account_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ClientRequest::set_has_account_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ClientRequest::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ClientRequest::clear_account_id() {
+  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_account_id();
+}
+inline const ::bgs::protocol::EntityId& ClientRequest::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientRequest.account_id)
+  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
+}
+inline ::bgs::protocol::EntityId* ClientRequest::mutable_account_id() {
+  set_has_account_id();
+  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ClientRequest.account_id)
+  return account_id_;
+}
+inline ::bgs::protocol::EntityId* ClientRequest::release_account_id() {
+  clear_has_account_id();
+  ::bgs::protocol::EntityId* temp = account_id_;
+  account_id_ = NULL;
+  return temp;
+}
+inline void ClientRequest::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.game_utilities.v1.ClientRequest.account_id)
+}
+
+// optional .bgs.protocol.EntityId game_account_id = 4;
+inline bool ClientRequest::has_game_account_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ClientRequest::set_has_game_account_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ClientRequest::clear_has_game_account_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ClientRequest::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& ClientRequest::game_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientRequest.game_account_id)
+  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
+}
+inline ::bgs::protocol::EntityId* ClientRequest::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.game_utilities.v1.ClientRequest.game_account_id)
+  return game_account_id_;
+}
+inline ::bgs::protocol::EntityId* ClientRequest::release_game_account_id() {
+  clear_has_game_account_id();
+  ::bgs::protocol::EntityId* temp = game_account_id_;
+  game_account_id_ = NULL;
+  return temp;
+}
+inline void ClientRequest::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.game_utilities.v1.ClientRequest.game_account_id)
+}
+
+// optional fixed32 program = 5;
+inline bool ClientRequest::has_program() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void ClientRequest::set_has_program() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void ClientRequest::clear_has_program() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void ClientRequest::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 ClientRequest::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientRequest.program)
+  return program_;
+}
+inline void ClientRequest::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.ClientRequest.program)
+}
+
+// optional .bgs.protocol.game_utilities.v1.ClientInfo client_info = 6;
+inline bool ClientRequest::has_client_info() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void ClientRequest::set_has_client_info() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void ClientRequest::clear_has_client_info() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void ClientRequest::clear_client_info() {
+  if (client_info_ != NULL) client_info_->::bgs::protocol::game_utilities::v1::ClientInfo::Clear();
+  clear_has_client_info();
+}
+inline const ::bgs::protocol::game_utilities::v1::ClientInfo& ClientRequest::client_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientRequest.client_info)
+  return client_info_ != NULL ? *client_info_ : *default_instance_->client_info_;
+}
+inline ::bgs::protocol::game_utilities::v1::ClientInfo* ClientRequest::mutable_client_info() {
+  set_has_client_info();
+  if (client_info_ == NULL) client_info_ = new ::bgs::protocol::game_utilities::v1::ClientInfo;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ClientRequest.client_info)
+  return client_info_;
+}
+inline ::bgs::protocol::game_utilities::v1::ClientInfo* ClientRequest::release_client_info() {
+  clear_has_client_info();
+  ::bgs::protocol::game_utilities::v1::ClientInfo* temp = client_info_;
+  client_info_ = NULL;
+  return temp;
+}
+inline void ClientRequest::set_allocated_client_info(::bgs::protocol::game_utilities::v1::ClientInfo* client_info) {
+  delete client_info_;
+  client_info_ = client_info;
+  if (client_info) {
+    set_has_client_info();
+  } else {
+    clear_has_client_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.ClientRequest.client_info)
+}
+
+// -------------------------------------------------------------------
+
+// ClientResponse
+
+// repeated .bgs.protocol.Attribute attribute = 1;
+inline int ClientResponse::attribute_size() const {
+  return attribute_.size();
+}
+inline void ClientResponse::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::Attribute& ClientResponse::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientResponse.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::Attribute* ClientResponse::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ClientResponse.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* ClientResponse::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.game_utilities.v1.ClientResponse.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+ClientResponse::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.game_utilities.v1.ClientResponse.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+ClientResponse::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.game_utilities.v1.ClientResponse.attribute)
+  return &attribute_;
+}
+
+// -------------------------------------------------------------------
+
+// ServerRequest
+
+// repeated .bgs.protocol.Attribute attribute = 1;
+inline int ServerRequest::attribute_size() const {
+  return attribute_.size();
+}
+inline void ServerRequest::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::Attribute& ServerRequest::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ServerRequest.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::Attribute* ServerRequest::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ServerRequest.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* ServerRequest::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.game_utilities.v1.ServerRequest.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+ServerRequest::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.game_utilities.v1.ServerRequest.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+ServerRequest::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.game_utilities.v1.ServerRequest.attribute)
+  return &attribute_;
+}
+
+// required fixed32 program = 2;
+inline bool ServerRequest::has_program() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ServerRequest::set_has_program() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ServerRequest::clear_has_program() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ServerRequest::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 ServerRequest::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ServerRequest.program)
+  return program_;
+}
+inline void ServerRequest::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.ServerRequest.program)
+}
+
+// optional .bgs.protocol.ProcessId host = 3;
+inline bool ServerRequest::has_host() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ServerRequest::set_has_host() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ServerRequest::clear_has_host() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ServerRequest::clear_host() {
+  if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+  clear_has_host();
+}
+inline const ::bgs::protocol::ProcessId& ServerRequest::host() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ServerRequest.host)
+  return host_ != NULL ? *host_ : *default_instance_->host_;
+}
+inline ::bgs::protocol::ProcessId* ServerRequest::mutable_host() {
+  set_has_host();
+  if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ServerRequest.host)
+  return host_;
+}
+inline ::bgs::protocol::ProcessId* ServerRequest::release_host() {
+  clear_has_host();
+  ::bgs::protocol::ProcessId* temp = host_;
+  host_ = NULL;
+  return temp;
+}
+inline void ServerRequest::set_allocated_host(::bgs::protocol::ProcessId* host) {
+  delete host_;
+  host_ = host;
+  if (host) {
+    set_has_host();
+  } else {
+    clear_has_host();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.ServerRequest.host)
+}
+
+// -------------------------------------------------------------------
+
+// ServerResponse
+
+// repeated .bgs.protocol.Attribute attribute = 1;
+inline int ServerResponse::attribute_size() const {
+  return attribute_.size();
+}
+inline void ServerResponse::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::Attribute& ServerResponse::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ServerResponse.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::Attribute* ServerResponse::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ServerResponse.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* ServerResponse::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.game_utilities.v1.ServerResponse.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+ServerResponse::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.game_utilities.v1.ServerResponse.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+ServerResponse::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.game_utilities.v1.ServerResponse.attribute)
+  return &attribute_;
+}
+
+// -------------------------------------------------------------------
+
+// PresenceChannelCreatedRequest
+
+// required .bgs.protocol.EntityId id = 1;
+inline bool PresenceChannelCreatedRequest::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void PresenceChannelCreatedRequest::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void PresenceChannelCreatedRequest::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void PresenceChannelCreatedRequest::clear_id() {
+  if (id_ != NULL) id_->::bgs::protocol::EntityId::Clear();
+  clear_has_id();
+}
+inline const ::bgs::protocol::EntityId& PresenceChannelCreatedRequest::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.id)
+  return id_ != NULL ? *id_ : *default_instance_->id_;
+}
+inline ::bgs::protocol::EntityId* PresenceChannelCreatedRequest::mutable_id() {
+  set_has_id();
+  if (id_ == NULL) id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.id)
+  return id_;
+}
+inline ::bgs::protocol::EntityId* PresenceChannelCreatedRequest::release_id() {
+  clear_has_id();
+  ::bgs::protocol::EntityId* temp = id_;
+  id_ = NULL;
+  return temp;
+}
+inline void PresenceChannelCreatedRequest::set_allocated_id(::bgs::protocol::EntityId* id) {
+  delete id_;
+  id_ = id;
+  if (id) {
+    set_has_id();
+  } else {
+    clear_has_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.id)
+}
+
+// optional .bgs.protocol.EntityId game_account_id = 3;
+inline bool PresenceChannelCreatedRequest::has_game_account_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void PresenceChannelCreatedRequest::set_has_game_account_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void PresenceChannelCreatedRequest::clear_has_game_account_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void PresenceChannelCreatedRequest::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& PresenceChannelCreatedRequest::game_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.game_account_id)
+  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
+}
+inline ::bgs::protocol::EntityId* PresenceChannelCreatedRequest::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.game_utilities.v1.PresenceChannelCreatedRequest.game_account_id)
+  return game_account_id_;
+}
+inline ::bgs::protocol::EntityId* PresenceChannelCreatedRequest::release_game_account_id() {
+  clear_has_game_account_id();
+  ::bgs::protocol::EntityId* temp = game_account_id_;
+  game_account_id_ = NULL;
+  return temp;
+}
+inline void PresenceChannelCreatedRequest::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.game_utilities.v1.PresenceChannelCreatedRequest.game_account_id)
+}
+
+// optional .bgs.protocol.EntityId account_id = 4;
+inline bool PresenceChannelCreatedRequest::has_account_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void PresenceChannelCreatedRequest::set_has_account_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void PresenceChannelCreatedRequest::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void PresenceChannelCreatedRequest::clear_account_id() {
+  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_account_id();
+}
+inline const ::bgs::protocol::EntityId& PresenceChannelCreatedRequest::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.account_id)
+  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
+}
+inline ::bgs::protocol::EntityId* PresenceChannelCreatedRequest::mutable_account_id() {
+  set_has_account_id();
+  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.account_id)
+  return account_id_;
+}
+inline ::bgs::protocol::EntityId* PresenceChannelCreatedRequest::release_account_id() {
+  clear_has_account_id();
+  ::bgs::protocol::EntityId* temp = account_id_;
+  account_id_ = NULL;
+  return temp;
+}
+inline void PresenceChannelCreatedRequest::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.game_utilities.v1.PresenceChannelCreatedRequest.account_id)
+}
+
+// optional .bgs.protocol.ProcessId host = 5;
+inline bool PresenceChannelCreatedRequest::has_host() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void PresenceChannelCreatedRequest::set_has_host() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void PresenceChannelCreatedRequest::clear_has_host() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void PresenceChannelCreatedRequest::clear_host() {
+  if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+  clear_has_host();
+}
+inline const ::bgs::protocol::ProcessId& PresenceChannelCreatedRequest::host() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.host)
+  return host_ != NULL ? *host_ : *default_instance_->host_;
+}
+inline ::bgs::protocol::ProcessId* PresenceChannelCreatedRequest::mutable_host() {
+  set_has_host();
+  if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.host)
+  return host_;
+}
+inline ::bgs::protocol::ProcessId* PresenceChannelCreatedRequest::release_host() {
+  clear_has_host();
+  ::bgs::protocol::ProcessId* temp = host_;
+  host_ = NULL;
+  return temp;
+}
+inline void PresenceChannelCreatedRequest::set_allocated_host(::bgs::protocol::ProcessId* host) {
+  delete host_;
+  host_ = host;
+  if (host) {
+    set_has_host();
+  } else {
+    clear_has_host();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.PresenceChannelCreatedRequest.host)
+}
+
+// -------------------------------------------------------------------
+
+// GetPlayerVariablesRequest
+
+// repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1;
+inline int GetPlayerVariablesRequest::player_variables_size() const {
+  return player_variables_.size();
+}
+inline void GetPlayerVariablesRequest::clear_player_variables() {
+  player_variables_.Clear();
+}
+inline const ::bgs::protocol::game_utilities::v1::PlayerVariables& GetPlayerVariablesRequest::player_variables(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest.player_variables)
+  return player_variables_.Get(index);
+}
+inline ::bgs::protocol::game_utilities::v1::PlayerVariables* GetPlayerVariablesRequest::mutable_player_variables(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest.player_variables)
+  return player_variables_.Mutable(index);
+}
+inline ::bgs::protocol::game_utilities::v1::PlayerVariables* GetPlayerVariablesRequest::add_player_variables() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest.player_variables)
+  return player_variables_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables >&
+GetPlayerVariablesRequest::player_variables() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest.player_variables)
+  return player_variables_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables >*
+GetPlayerVariablesRequest::mutable_player_variables() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest.player_variables)
+  return &player_variables_;
+}
+
+// optional .bgs.protocol.ProcessId host = 2;
+inline bool GetPlayerVariablesRequest::has_host() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetPlayerVariablesRequest::set_has_host() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetPlayerVariablesRequest::clear_has_host() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetPlayerVariablesRequest::clear_host() {
+  if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+  clear_has_host();
+}
+inline const ::bgs::protocol::ProcessId& GetPlayerVariablesRequest::host() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest.host)
+  return host_ != NULL ? *host_ : *default_instance_->host_;
+}
+inline ::bgs::protocol::ProcessId* GetPlayerVariablesRequest::mutable_host() {
+  set_has_host();
+  if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest.host)
+  return host_;
+}
+inline ::bgs::protocol::ProcessId* GetPlayerVariablesRequest::release_host() {
+  clear_has_host();
+  ::bgs::protocol::ProcessId* temp = host_;
+  host_ = NULL;
+  return temp;
+}
+inline void GetPlayerVariablesRequest::set_allocated_host(::bgs::protocol::ProcessId* host) {
+  delete host_;
+  host_ = host;
+  if (host) {
+    set_has_host();
+  } else {
+    clear_has_host();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GetPlayerVariablesRequest.host)
+}
+
+// -------------------------------------------------------------------
+
+// GetPlayerVariablesResponse
+
+// repeated .bgs.protocol.game_utilities.v1.PlayerVariables player_variables = 1;
+inline int GetPlayerVariablesResponse::player_variables_size() const {
+  return player_variables_.size();
+}
+inline void GetPlayerVariablesResponse::clear_player_variables() {
+  player_variables_.Clear();
+}
+inline const ::bgs::protocol::game_utilities::v1::PlayerVariables& GetPlayerVariablesResponse::player_variables(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse.player_variables)
+  return player_variables_.Get(index);
+}
+inline ::bgs::protocol::game_utilities::v1::PlayerVariables* GetPlayerVariablesResponse::mutable_player_variables(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse.player_variables)
+  return player_variables_.Mutable(index);
+}
+inline ::bgs::protocol::game_utilities::v1::PlayerVariables* GetPlayerVariablesResponse::add_player_variables() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse.player_variables)
+  return player_variables_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables >&
+GetPlayerVariablesResponse::player_variables() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse.player_variables)
+  return player_variables_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::game_utilities::v1::PlayerVariables >*
+GetPlayerVariablesResponse::mutable_player_variables() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.game_utilities.v1.GetPlayerVariablesResponse.player_variables)
+  return &player_variables_;
+}
+
+// -------------------------------------------------------------------
+
+// GameAccountOnlineNotification
+
+// required .bgs.protocol.EntityId game_account_id = 1;
+inline bool GameAccountOnlineNotification::has_game_account_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameAccountOnlineNotification::set_has_game_account_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameAccountOnlineNotification::clear_has_game_account_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameAccountOnlineNotification::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& GameAccountOnlineNotification::game_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.game_account_id)
+  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
+}
+inline ::bgs::protocol::EntityId* GameAccountOnlineNotification::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.game_utilities.v1.GameAccountOnlineNotification.game_account_id)
+  return game_account_id_;
+}
+inline ::bgs::protocol::EntityId* GameAccountOnlineNotification::release_game_account_id() {
+  clear_has_game_account_id();
+  ::bgs::protocol::EntityId* temp = game_account_id_;
+  game_account_id_ = NULL;
+  return temp;
+}
+inline void GameAccountOnlineNotification::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.game_utilities.v1.GameAccountOnlineNotification.game_account_id)
+}
+
+// optional .bgs.protocol.ProcessId host = 2;
+inline bool GameAccountOnlineNotification::has_host() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameAccountOnlineNotification::set_has_host() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameAccountOnlineNotification::clear_has_host() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameAccountOnlineNotification::clear_host() {
+  if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+  clear_has_host();
+}
+inline const ::bgs::protocol::ProcessId& GameAccountOnlineNotification::host() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.host)
+  return host_ != NULL ? *host_ : *default_instance_->host_;
+}
+inline ::bgs::protocol::ProcessId* GameAccountOnlineNotification::mutable_host() {
+  set_has_host();
+  if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.host)
+  return host_;
+}
+inline ::bgs::protocol::ProcessId* GameAccountOnlineNotification::release_host() {
+  clear_has_host();
+  ::bgs::protocol::ProcessId* temp = host_;
+  host_ = NULL;
+  return temp;
+}
+inline void GameAccountOnlineNotification::set_allocated_host(::bgs::protocol::ProcessId* host) {
+  delete host_;
+  host_ = host;
+  if (host) {
+    set_has_host();
+  } else {
+    clear_has_host();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.host)
+}
+
+// optional string session_id = 3;
+inline bool GameAccountOnlineNotification::has_session_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GameAccountOnlineNotification::set_has_session_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GameAccountOnlineNotification::clear_has_session_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GameAccountOnlineNotification::clear_session_id() {
+  if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    session_id_->clear();
+  }
+  clear_has_session_id();
+}
+inline const ::std::string& GameAccountOnlineNotification::session_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.session_id)
+  return *session_id_;
+}
+inline void GameAccountOnlineNotification::set_session_id(const ::std::string& value) {
+  set_has_session_id();
+  if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    session_id_ = new ::std::string;
+  }
+  session_id_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.session_id)
+}
+inline void GameAccountOnlineNotification::set_session_id(const char* value) {
+  set_has_session_id();
+  if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    session_id_ = new ::std::string;
+  }
+  session_id_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.session_id)
+}
+inline void GameAccountOnlineNotification::set_session_id(const char* value, size_t size) {
+  set_has_session_id();
+  if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    session_id_ = new ::std::string;
+  }
+  session_id_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.session_id)
+}
+inline ::std::string* GameAccountOnlineNotification::mutable_session_id() {
+  set_has_session_id();
+  if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    session_id_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.session_id)
+  return session_id_;
+}
+inline ::std::string* GameAccountOnlineNotification::release_session_id() {
+  clear_has_session_id();
+  if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = session_id_;
+    session_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void GameAccountOnlineNotification::set_allocated_session_id(::std::string* session_id) {
+  if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete session_id_;
+  }
+  if (session_id) {
+    set_has_session_id();
+    session_id_ = session_id;
+  } else {
+    clear_has_session_id();
+    session_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GameAccountOnlineNotification.session_id)
+}
+
+// -------------------------------------------------------------------
+
+// GameAccountOfflineNotification
+
+// required .bgs.protocol.EntityId game_account_id = 1;
+inline bool GameAccountOfflineNotification::has_game_account_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GameAccountOfflineNotification::set_has_game_account_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GameAccountOfflineNotification::clear_has_game_account_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GameAccountOfflineNotification::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& GameAccountOfflineNotification::game_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.game_account_id)
+  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
+}
+inline ::bgs::protocol::EntityId* GameAccountOfflineNotification::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.game_utilities.v1.GameAccountOfflineNotification.game_account_id)
+  return game_account_id_;
+}
+inline ::bgs::protocol::EntityId* GameAccountOfflineNotification::release_game_account_id() {
+  clear_has_game_account_id();
+  ::bgs::protocol::EntityId* temp = game_account_id_;
+  game_account_id_ = NULL;
+  return temp;
+}
+inline void GameAccountOfflineNotification::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.game_utilities.v1.GameAccountOfflineNotification.game_account_id)
+}
+
+// optional .bgs.protocol.ProcessId host = 2;
+inline bool GameAccountOfflineNotification::has_host() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GameAccountOfflineNotification::set_has_host() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GameAccountOfflineNotification::clear_has_host() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GameAccountOfflineNotification::clear_host() {
+  if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+  clear_has_host();
+}
+inline const ::bgs::protocol::ProcessId& GameAccountOfflineNotification::host() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.host)
+  return host_ != NULL ? *host_ : *default_instance_->host_;
+}
+inline ::bgs::protocol::ProcessId* GameAccountOfflineNotification::mutable_host() {
+  set_has_host();
+  if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.host)
+  return host_;
+}
+inline ::bgs::protocol::ProcessId* GameAccountOfflineNotification::release_host() {
+  clear_has_host();
+  ::bgs::protocol::ProcessId* temp = host_;
+  host_ = NULL;
+  return temp;
+}
+inline void GameAccountOfflineNotification::set_allocated_host(::bgs::protocol::ProcessId* host) {
+  delete host_;
+  host_ = host;
+  if (host) {
+    set_has_host();
+  } else {
+    clear_has_host();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.host)
+}
+
+// optional string session_id = 3;
+inline bool GameAccountOfflineNotification::has_session_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GameAccountOfflineNotification::set_has_session_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GameAccountOfflineNotification::clear_has_session_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GameAccountOfflineNotification::clear_session_id() {
+  if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    session_id_->clear();
+  }
+  clear_has_session_id();
+}
+inline const ::std::string& GameAccountOfflineNotification::session_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.session_id)
+  return *session_id_;
+}
+inline void GameAccountOfflineNotification::set_session_id(const ::std::string& value) {
+  set_has_session_id();
+  if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    session_id_ = new ::std::string;
+  }
+  session_id_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.session_id)
+}
+inline void GameAccountOfflineNotification::set_session_id(const char* value) {
+  set_has_session_id();
+  if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    session_id_ = new ::std::string;
+  }
+  session_id_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.session_id)
+}
+inline void GameAccountOfflineNotification::set_session_id(const char* value, size_t size) {
+  set_has_session_id();
+  if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    session_id_ = new ::std::string;
+  }
+  session_id_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.session_id)
+}
+inline ::std::string* GameAccountOfflineNotification::mutable_session_id() {
+  set_has_session_id();
+  if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    session_id_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.session_id)
+  return session_id_;
+}
+inline ::std::string* GameAccountOfflineNotification::release_session_id() {
+  clear_has_session_id();
+  if (session_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = session_id_;
+    session_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void GameAccountOfflineNotification::set_allocated_session_id(::std::string* session_id) {
+  if (session_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete session_id_;
+  }
+  if (session_id) {
+    set_has_session_id();
+    session_id_ = session_id;
+  } else {
+    clear_has_session_id();
+    session_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GameAccountOfflineNotification.session_id)
+}
+
+// -------------------------------------------------------------------
+
+// GetAchievementsFileRequest
+
+// optional .bgs.protocol.ProcessId host = 1;
+inline bool GetAchievementsFileRequest::has_host() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetAchievementsFileRequest::set_has_host() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetAchievementsFileRequest::clear_has_host() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetAchievementsFileRequest::clear_host() {
+  if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+  clear_has_host();
+}
+inline const ::bgs::protocol::ProcessId& GetAchievementsFileRequest::host() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest.host)
+  return host_ != NULL ? *host_ : *default_instance_->host_;
+}
+inline ::bgs::protocol::ProcessId* GetAchievementsFileRequest::mutable_host() {
+  set_has_host();
+  if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest.host)
+  return host_;
+}
+inline ::bgs::protocol::ProcessId* GetAchievementsFileRequest::release_host() {
+  clear_has_host();
+  ::bgs::protocol::ProcessId* temp = host_;
+  host_ = NULL;
+  return temp;
+}
+inline void GetAchievementsFileRequest::set_allocated_host(::bgs::protocol::ProcessId* host) {
+  delete host_;
+  host_ = host;
+  if (host) {
+    set_has_host();
+  } else {
+    clear_has_host();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GetAchievementsFileRequest.host)
+}
+
+// -------------------------------------------------------------------
+
+// GetAchievementsFileResponse
+
+// optional .bgs.protocol.ContentHandle content_handle = 1;
+inline bool GetAchievementsFileResponse::has_content_handle() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetAchievementsFileResponse::set_has_content_handle() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetAchievementsFileResponse::clear_has_content_handle() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetAchievementsFileResponse::clear_content_handle() {
+  if (content_handle_ != NULL) content_handle_->::bgs::protocol::ContentHandle::Clear();
+  clear_has_content_handle();
+}
+inline const ::bgs::protocol::ContentHandle& GetAchievementsFileResponse::content_handle() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse.content_handle)
+  return content_handle_ != NULL ? *content_handle_ : *default_instance_->content_handle_;
+}
+inline ::bgs::protocol::ContentHandle* GetAchievementsFileResponse::mutable_content_handle() {
+  set_has_content_handle();
+  if (content_handle_ == NULL) content_handle_ = new ::bgs::protocol::ContentHandle;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse.content_handle)
+  return content_handle_;
+}
+inline ::bgs::protocol::ContentHandle* GetAchievementsFileResponse::release_content_handle() {
+  clear_has_content_handle();
+  ::bgs::protocol::ContentHandle* temp = content_handle_;
+  content_handle_ = NULL;
+  return temp;
+}
+inline void GetAchievementsFileResponse::set_allocated_content_handle(::bgs::protocol::ContentHandle* content_handle) {
+  delete content_handle_;
+  content_handle_ = content_handle;
+  if (content_handle) {
+    set_has_content_handle();
+  } else {
+    clear_has_content_handle();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GetAchievementsFileResponse.content_handle)
+}
+
+// -------------------------------------------------------------------
+
+// GetAllValuesForAttributeRequest
+
+// optional string attribute_key = 1;
+inline bool GetAllValuesForAttributeRequest::has_attribute_key() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GetAllValuesForAttributeRequest::set_has_attribute_key() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GetAllValuesForAttributeRequest::clear_has_attribute_key() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GetAllValuesForAttributeRequest::clear_attribute_key() {
+  if (attribute_key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    attribute_key_->clear();
+  }
+  clear_has_attribute_key();
+}
+inline const ::std::string& GetAllValuesForAttributeRequest::attribute_key() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.attribute_key)
+  return *attribute_key_;
+}
+inline void GetAllValuesForAttributeRequest::set_attribute_key(const ::std::string& value) {
+  set_has_attribute_key();
+  if (attribute_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    attribute_key_ = new ::std::string;
+  }
+  attribute_key_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.attribute_key)
+}
+inline void GetAllValuesForAttributeRequest::set_attribute_key(const char* value) {
+  set_has_attribute_key();
+  if (attribute_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    attribute_key_ = new ::std::string;
+  }
+  attribute_key_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.attribute_key)
+}
+inline void GetAllValuesForAttributeRequest::set_attribute_key(const char* value, size_t size) {
+  set_has_attribute_key();
+  if (attribute_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    attribute_key_ = new ::std::string;
+  }
+  attribute_key_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.attribute_key)
+}
+inline ::std::string* GetAllValuesForAttributeRequest::mutable_attribute_key() {
+  set_has_attribute_key();
+  if (attribute_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    attribute_key_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.attribute_key)
+  return attribute_key_;
+}
+inline ::std::string* GetAllValuesForAttributeRequest::release_attribute_key() {
+  clear_has_attribute_key();
+  if (attribute_key_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = attribute_key_;
+    attribute_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void GetAllValuesForAttributeRequest::set_allocated_attribute_key(::std::string* attribute_key) {
+  if (attribute_key_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete attribute_key_;
+  }
+  if (attribute_key) {
+    set_has_attribute_key();
+    attribute_key_ = attribute_key;
+  } else {
+    clear_has_attribute_key();
+    attribute_key_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.attribute_key)
+}
+
+// optional .bgs.protocol.EntityId agent_id = 2;
+inline bool GetAllValuesForAttributeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GetAllValuesForAttributeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GetAllValuesForAttributeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GetAllValuesForAttributeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& GetAllValuesForAttributeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* GetAllValuesForAttributeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* GetAllValuesForAttributeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GetAllValuesForAttributeRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.agent_id)
+}
+
+// optional fixed32 program = 5;
+inline bool GetAllValuesForAttributeRequest::has_program() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GetAllValuesForAttributeRequest::set_has_program() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GetAllValuesForAttributeRequest::clear_has_program() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GetAllValuesForAttributeRequest::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 GetAllValuesForAttributeRequest::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.program)
+  return program_;
+}
+inline void GetAllValuesForAttributeRequest::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeRequest.program)
+}
+
+// -------------------------------------------------------------------
+
+// GetAllValuesForAttributeResponse
+
+// repeated .bgs.protocol.Variant attribute_value = 1;
+inline int GetAllValuesForAttributeResponse::attribute_value_size() const {
+  return attribute_value_.size();
+}
+inline void GetAllValuesForAttributeResponse::clear_attribute_value() {
+  attribute_value_.Clear();
+}
+inline const ::bgs::protocol::Variant& GetAllValuesForAttributeResponse::attribute_value(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse.attribute_value)
+  return attribute_value_.Get(index);
+}
+inline ::bgs::protocol::Variant* GetAllValuesForAttributeResponse::mutable_attribute_value(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse.attribute_value)
+  return attribute_value_.Mutable(index);
+}
+inline ::bgs::protocol::Variant* GetAllValuesForAttributeResponse::add_attribute_value() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse.attribute_value)
+  return attribute_value_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Variant >&
+GetAllValuesForAttributeResponse::attribute_value() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse.attribute_value)
+  return attribute_value_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Variant >*
+GetAllValuesForAttributeResponse::mutable_attribute_value() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.game_utilities.v1.GetAllValuesForAttributeResponse.attribute_value)
+  return &attribute_value_;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace game_utilities
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_game_5futilities_5fservice_2eproto__INCLUDED
diff --git a/src/server/proto/Client/game_utilities_types.pb.cc b/src/server/proto/Client/game_utilities_types.pb.cc
new file mode 100644
index 00000000000..cb72ee88ef3
--- /dev/null
+++ b/src/server/proto/Client/game_utilities_types.pb.cc
@@ -0,0 +1,742 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: game_utilities_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "game_utilities_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace game_utilities {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* PlayerVariables_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  PlayerVariables_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClientInfo_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClientInfo_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_game_5futilities_5ftypes_2eproto() {
+  protobuf_AddDesc_game_5futilities_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "game_utilities_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  PlayerVariables_descriptor_ = file->message_type(0);
+  static const int PlayerVariables_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlayerVariables, identity_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlayerVariables, rating_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlayerVariables, attribute_),
+  };
+  PlayerVariables_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      PlayerVariables_descriptor_,
+      PlayerVariables::default_instance_,
+      PlayerVariables_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlayerVariables, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PlayerVariables, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(PlayerVariables));
+  ClientInfo_descriptor_ = file->message_type(1);
+  static const int ClientInfo_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientInfo, client_address_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientInfo, privileged_network_),
+  };
+  ClientInfo_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClientInfo_descriptor_,
+      ClientInfo::default_instance_,
+      ClientInfo_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientInfo, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClientInfo, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClientInfo));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_game_5futilities_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    PlayerVariables_descriptor_, &PlayerVariables::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClientInfo_descriptor_, &ClientInfo::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_game_5futilities_5ftypes_2eproto() {
+  delete PlayerVariables::default_instance_;
+  delete PlayerVariables_reflection_;
+  delete ClientInfo::default_instance_;
+  delete ClientInfo_reflection_;
+}
+
+void protobuf_AddDesc_game_5futilities_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\032game_utilities_types.proto\022\036bgs.protoc"
+    "ol.game_utilities.v1\032\025attribute_types.pr"
+    "oto\032\022entity_types.proto\"w\n\017PlayerVariabl"
+    "es\022(\n\010identity\030\001 \002(\0132\026.bgs.protocol.Iden"
+    "tity\022\016\n\006rating\030\002 \001(\001\022*\n\tattribute\030\003 \003(\0132"
+    "\027.bgs.protocol.Attribute\"@\n\nClientInfo\022\026"
+    "\n\016client_address\030\001 \001(\t\022\032\n\022privileged_net"
+    "work\030\002 \001(\010B<\n\037bnet.protocol.game_utiliti"
+    "es.v1B\027GameUtilitiesTypesProtoH\001", 352);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "game_utilities_types.proto", &protobuf_RegisterTypes);
+  PlayerVariables::default_instance_ = new PlayerVariables();
+  ClientInfo::default_instance_ = new ClientInfo();
+  PlayerVariables::default_instance_->InitAsDefaultInstance();
+  ClientInfo::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_game_5futilities_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_game_5futilities_5ftypes_2eproto {
+  StaticDescriptorInitializer_game_5futilities_5ftypes_2eproto() {
+    protobuf_AddDesc_game_5futilities_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_game_5futilities_5ftypes_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int PlayerVariables::kIdentityFieldNumber;
+const int PlayerVariables::kRatingFieldNumber;
+const int PlayerVariables::kAttributeFieldNumber;
+#endif  // !_MSC_VER
+
+PlayerVariables::PlayerVariables()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.PlayerVariables)
+}
+
+void PlayerVariables::InitAsDefaultInstance() {
+  identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance());
+}
+
+PlayerVariables::PlayerVariables(const PlayerVariables& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.PlayerVariables)
+}
+
+void PlayerVariables::SharedCtor() {
+  _cached_size_ = 0;
+  identity_ = NULL;
+  rating_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+PlayerVariables::~PlayerVariables() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.PlayerVariables)
+  SharedDtor();
+}
+
+void PlayerVariables::SharedDtor() {
+  if (this != default_instance_) {
+    delete identity_;
+  }
+}
+
+void PlayerVariables::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* PlayerVariables::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PlayerVariables_descriptor_;
+}
+
+const PlayerVariables& PlayerVariables::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+PlayerVariables* PlayerVariables::default_instance_ = NULL;
+
+PlayerVariables* PlayerVariables::New() const {
+  return new PlayerVariables;
+}
+
+void PlayerVariables::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_identity()) {
+      if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear();
+    }
+    rating_ = 0;
+  }
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool PlayerVariables::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.PlayerVariables)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.Identity identity = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_identity()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(17)) goto parse_rating;
+        break;
+      }
+
+      // optional double rating = 2;
+      case 2: {
+        if (tag == 17) {
+         parse_rating:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>(
+                 input, &rating_)));
+          set_has_rating();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.Attribute attribute = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_attribute;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.game_utilities.v1.PlayerVariables)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.PlayerVariables)
+  return false;
+#undef DO_
+}
+
+void PlayerVariables::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.PlayerVariables)
+  // required .bgs.protocol.Identity identity = 1;
+  if (has_identity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->identity(), output);
+  }
+
+  // optional double rating = 2;
+  if (has_rating()) {
+    ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->rating(), output);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->attribute(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.PlayerVariables)
+}
+
+::google::protobuf::uint8* PlayerVariables::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.PlayerVariables)
+  // required .bgs.protocol.Identity identity = 1;
+  if (has_identity()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->identity(), target);
+  }
+
+  // optional double rating = 2;
+  if (has_rating()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(2, this->rating(), target);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 3;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->attribute(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.PlayerVariables)
+  return target;
+}
+
+int PlayerVariables::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.Identity identity = 1;
+    if (has_identity()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->identity());
+    }
+
+    // optional double rating = 2;
+    if (has_rating()) {
+      total_size += 1 + 8;
+    }
+
+  }
+  // repeated .bgs.protocol.Attribute attribute = 3;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void PlayerVariables::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const PlayerVariables* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const PlayerVariables*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void PlayerVariables::MergeFrom(const PlayerVariables& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_identity()) {
+      mutable_identity()->::bgs::protocol::Identity::MergeFrom(from.identity());
+    }
+    if (from.has_rating()) {
+      set_rating(from.rating());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void PlayerVariables::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void PlayerVariables::CopyFrom(const PlayerVariables& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool PlayerVariables::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_identity()) {
+    if (!this->identity().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
+  return true;
+}
+
+void PlayerVariables::Swap(PlayerVariables* other) {
+  if (other != this) {
+    std::swap(identity_, other->identity_);
+    std::swap(rating_, other->rating_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata PlayerVariables::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = PlayerVariables_descriptor_;
+  metadata.reflection = PlayerVariables_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClientInfo::kClientAddressFieldNumber;
+const int ClientInfo::kPrivilegedNetworkFieldNumber;
+#endif  // !_MSC_VER
+
+ClientInfo::ClientInfo()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.game_utilities.v1.ClientInfo)
+}
+
+void ClientInfo::InitAsDefaultInstance() {
+}
+
+ClientInfo::ClientInfo(const ClientInfo& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.game_utilities.v1.ClientInfo)
+}
+
+void ClientInfo::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  client_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  privileged_network_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClientInfo::~ClientInfo() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.game_utilities.v1.ClientInfo)
+  SharedDtor();
+}
+
+void ClientInfo::SharedDtor() {
+  if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_address_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ClientInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClientInfo::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClientInfo_descriptor_;
+}
+
+const ClientInfo& ClientInfo::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_game_5futilities_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ClientInfo* ClientInfo::default_instance_ = NULL;
+
+ClientInfo* ClientInfo::New() const {
+  return new ClientInfo;
+}
+
+void ClientInfo::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_client_address()) {
+      if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        client_address_->clear();
+      }
+    }
+    privileged_network_ = false;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClientInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.game_utilities.v1.ClientInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string client_address = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_client_address()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->client_address().data(), this->client_address().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "client_address");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_privileged_network;
+        break;
+      }
+
+      // optional bool privileged_network = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_privileged_network:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &privileged_network_)));
+          set_has_privileged_network();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.game_utilities.v1.ClientInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.game_utilities.v1.ClientInfo)
+  return false;
+#undef DO_
+}
+
+void ClientInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.game_utilities.v1.ClientInfo)
+  // optional string client_address = 1;
+  if (has_client_address()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->client_address().data(), this->client_address().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "client_address");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->client_address(), output);
+  }
+
+  // optional bool privileged_network = 2;
+  if (has_privileged_network()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->privileged_network(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.game_utilities.v1.ClientInfo)
+}
+
+::google::protobuf::uint8* ClientInfo::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.game_utilities.v1.ClientInfo)
+  // optional string client_address = 1;
+  if (has_client_address()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->client_address().data(), this->client_address().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "client_address");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->client_address(), target);
+  }
+
+  // optional bool privileged_network = 2;
+  if (has_privileged_network()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->privileged_network(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.game_utilities.v1.ClientInfo)
+  return target;
+}
+
+int ClientInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string client_address = 1;
+    if (has_client_address()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->client_address());
+    }
+
+    // optional bool privileged_network = 2;
+    if (has_privileged_network()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClientInfo::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClientInfo* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClientInfo*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClientInfo::MergeFrom(const ClientInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_client_address()) {
+      set_client_address(from.client_address());
+    }
+    if (from.has_privileged_network()) {
+      set_privileged_network(from.privileged_network());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClientInfo::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClientInfo::CopyFrom(const ClientInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClientInfo::IsInitialized() const {
+
+  return true;
+}
+
+void ClientInfo::Swap(ClientInfo* other) {
+  if (other != this) {
+    std::swap(client_address_, other->client_address_);
+    std::swap(privileged_network_, other->privileged_network_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClientInfo::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClientInfo_descriptor_;
+  metadata.reflection = ClientInfo_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace game_utilities
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/game_utilities_types.pb.h b/src/server/proto/Client/game_utilities_types.pb.h
new file mode 100644
index 00000000000..dc9a1eb4060
--- /dev/null
+++ b/src/server/proto/Client/game_utilities_types.pb.h
@@ -0,0 +1,471 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: game_utilities_types.proto
+
+#ifndef PROTOBUF_game_5futilities_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_game_5futilities_5ftypes_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 "attribute_types.pb.h"
+#include "entity_types.pb.h"
+#include "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace game_utilities {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_game_5futilities_5ftypes_2eproto();
+void protobuf_AssignDesc_game_5futilities_5ftypes_2eproto();
+void protobuf_ShutdownFile_game_5futilities_5ftypes_2eproto();
+
+class PlayerVariables;
+class ClientInfo;
+
+// ===================================================================
+
+class TC_SHARED_API PlayerVariables : public ::google::protobuf::Message {
+ public:
+  PlayerVariables();
+  virtual ~PlayerVariables();
+
+  PlayerVariables(const PlayerVariables& from);
+
+  inline PlayerVariables& operator=(const PlayerVariables& 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 PlayerVariables& default_instance();
+
+  void Swap(PlayerVariables* other);
+
+  // implements Message ----------------------------------------------
+
+  PlayerVariables* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const PlayerVariables& from);
+  void MergeFrom(const PlayerVariables& 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.Identity identity = 1;
+  inline bool has_identity() const;
+  inline void clear_identity();
+  static const int kIdentityFieldNumber = 1;
+  inline const ::bgs::protocol::Identity& identity() const;
+  inline ::bgs::protocol::Identity* mutable_identity();
+  inline ::bgs::protocol::Identity* release_identity();
+  inline void set_allocated_identity(::bgs::protocol::Identity* identity);
+
+  // optional double rating = 2;
+  inline bool has_rating() const;
+  inline void clear_rating();
+  static const int kRatingFieldNumber = 2;
+  inline double rating() const;
+  inline void set_rating(double value);
+
+  // repeated .bgs.protocol.Attribute attribute = 3;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 3;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.PlayerVariables)
+ private:
+  inline void set_has_identity();
+  inline void clear_has_identity();
+  inline void set_has_rating();
+  inline void clear_has_rating();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::Identity* identity_;
+  double rating_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
+  friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_game_5futilities_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_game_5futilities_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static PlayerVariables* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ClientInfo : public ::google::protobuf::Message {
+ public:
+  ClientInfo();
+  virtual ~ClientInfo();
+
+  ClientInfo(const ClientInfo& from);
+
+  inline ClientInfo& operator=(const ClientInfo& 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 ClientInfo& default_instance();
+
+  void Swap(ClientInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  ClientInfo* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClientInfo& from);
+  void MergeFrom(const ClientInfo& 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 client_address = 1;
+  inline bool has_client_address() const;
+  inline void clear_client_address();
+  static const int kClientAddressFieldNumber = 1;
+  inline const ::std::string& client_address() const;
+  inline void set_client_address(const ::std::string& value);
+  inline void set_client_address(const char* value);
+  inline void set_client_address(const char* value, size_t size);
+  inline ::std::string* mutable_client_address();
+  inline ::std::string* release_client_address();
+  inline void set_allocated_client_address(::std::string* client_address);
+
+  // optional bool privileged_network = 2;
+  inline bool has_privileged_network() const;
+  inline void clear_privileged_network();
+  static const int kPrivilegedNetworkFieldNumber = 2;
+  inline bool privileged_network() const;
+  inline void set_privileged_network(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.game_utilities.v1.ClientInfo)
+ private:
+  inline void set_has_client_address();
+  inline void clear_has_client_address();
+  inline void set_has_privileged_network();
+  inline void clear_has_privileged_network();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* client_address_;
+  bool privileged_network_;
+  friend void TC_SHARED_API protobuf_AddDesc_game_5futilities_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_game_5futilities_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_game_5futilities_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClientInfo* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// PlayerVariables
+
+// required .bgs.protocol.Identity identity = 1;
+inline bool PlayerVariables::has_identity() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void PlayerVariables::set_has_identity() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void PlayerVariables::clear_has_identity() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void PlayerVariables::clear_identity() {
+  if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear();
+  clear_has_identity();
+}
+inline const ::bgs::protocol::Identity& PlayerVariables::identity() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.PlayerVariables.identity)
+  return identity_ != NULL ? *identity_ : *default_instance_->identity_;
+}
+inline ::bgs::protocol::Identity* PlayerVariables::mutable_identity() {
+  set_has_identity();
+  if (identity_ == NULL) identity_ = new ::bgs::protocol::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.PlayerVariables.identity)
+  return identity_;
+}
+inline ::bgs::protocol::Identity* PlayerVariables::release_identity() {
+  clear_has_identity();
+  ::bgs::protocol::Identity* temp = identity_;
+  identity_ = NULL;
+  return temp;
+}
+inline void PlayerVariables::set_allocated_identity(::bgs::protocol::Identity* identity) {
+  delete identity_;
+  identity_ = identity;
+  if (identity) {
+    set_has_identity();
+  } else {
+    clear_has_identity();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.PlayerVariables.identity)
+}
+
+// optional double rating = 2;
+inline bool PlayerVariables::has_rating() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void PlayerVariables::set_has_rating() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void PlayerVariables::clear_has_rating() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void PlayerVariables::clear_rating() {
+  rating_ = 0;
+  clear_has_rating();
+}
+inline double PlayerVariables::rating() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.PlayerVariables.rating)
+  return rating_;
+}
+inline void PlayerVariables::set_rating(double value) {
+  set_has_rating();
+  rating_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.PlayerVariables.rating)
+}
+
+// repeated .bgs.protocol.Attribute attribute = 3;
+inline int PlayerVariables::attribute_size() const {
+  return attribute_.size();
+}
+inline void PlayerVariables::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::Attribute& PlayerVariables::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.PlayerVariables.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::Attribute* PlayerVariables::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.PlayerVariables.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* PlayerVariables::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.game_utilities.v1.PlayerVariables.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+PlayerVariables::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.game_utilities.v1.PlayerVariables.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+PlayerVariables::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.game_utilities.v1.PlayerVariables.attribute)
+  return &attribute_;
+}
+
+// -------------------------------------------------------------------
+
+// ClientInfo
+
+// optional string client_address = 1;
+inline bool ClientInfo::has_client_address() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClientInfo::set_has_client_address() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClientInfo::clear_has_client_address() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClientInfo::clear_client_address() {
+  if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_address_->clear();
+  }
+  clear_has_client_address();
+}
+inline const ::std::string& ClientInfo::client_address() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientInfo.client_address)
+  return *client_address_;
+}
+inline void ClientInfo::set_client_address(const ::std::string& value) {
+  set_has_client_address();
+  if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_address_ = new ::std::string;
+  }
+  client_address_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.ClientInfo.client_address)
+}
+inline void ClientInfo::set_client_address(const char* value) {
+  set_has_client_address();
+  if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_address_ = new ::std::string;
+  }
+  client_address_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.game_utilities.v1.ClientInfo.client_address)
+}
+inline void ClientInfo::set_client_address(const char* value, size_t size) {
+  set_has_client_address();
+  if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_address_ = new ::std::string;
+  }
+  client_address_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.game_utilities.v1.ClientInfo.client_address)
+}
+inline ::std::string* ClientInfo::mutable_client_address() {
+  set_has_client_address();
+  if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_address_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.game_utilities.v1.ClientInfo.client_address)
+  return client_address_;
+}
+inline ::std::string* ClientInfo::release_client_address() {
+  clear_has_client_address();
+  if (client_address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = client_address_;
+    client_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ClientInfo::set_allocated_client_address(::std::string* client_address) {
+  if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_address_;
+  }
+  if (client_address) {
+    set_has_client_address();
+    client_address_ = client_address;
+  } else {
+    clear_has_client_address();
+    client_address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.game_utilities.v1.ClientInfo.client_address)
+}
+
+// optional bool privileged_network = 2;
+inline bool ClientInfo::has_privileged_network() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClientInfo::set_has_privileged_network() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClientInfo::clear_has_privileged_network() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClientInfo::clear_privileged_network() {
+  privileged_network_ = false;
+  clear_has_privileged_network();
+}
+inline bool ClientInfo::privileged_network() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.game_utilities.v1.ClientInfo.privileged_network)
+  return privileged_network_;
+}
+inline void ClientInfo::set_privileged_network(bool value) {
+  set_has_privileged_network();
+  privileged_network_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.game_utilities.v1.ClientInfo.privileged_network)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace game_utilities
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_game_5futilities_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/global_extensions/field_options.pb.cc b/src/server/proto/Client/global_extensions/field_options.pb.cc
new file mode 100644
index 00000000000..f5a1e999417
--- /dev/null
+++ b/src/server/proto/Client/global_extensions/field_options.pb.cc
@@ -0,0 +1,114 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: global_extensions/field_options.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "global_extensions/field_options.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+
+namespace {
+
+const ::google::protobuf::EnumDescriptor* LogOption_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto() {
+  protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "global_extensions/field_options.proto");
+  GOOGLE_CHECK(file != NULL);
+  LogOption_descriptor_ = file->enum_type(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto() {
+}
+
+void protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n%global_extensions/field_options.proto\022"
+    "\014bgs.protocol\032 google/protobuf/descripto"
+    "r.proto* \n\tLogOption\022\n\n\006HIDDEN\020\001\022\007\n\003HEX\020"
+    "\002:E\n\003log\022\035.google.protobuf.FieldOptions\030"
+    "\320\206\003 \001(\0162\027.bgs.protocol.LogOptionB$\n\rbnet"
+    ".protocolB\021FieldOptionsProtoH\001", 230);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "global_extensions/field_options.proto", &protobuf_RegisterTypes);
+  ::google::protobuf::internal::ExtensionSet::RegisterEnumExtension(
+    &::google::protobuf::FieldOptions::default_instance(),
+    50000, 14, false, false,
+    &::bgs::protocol::LogOption_IsValid);
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_global_5fextensions_2ffield_5foptions_2eproto {
+  StaticDescriptorInitializer_global_5fextensions_2ffield_5foptions_2eproto() {
+    protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  }
+} static_descriptor_initializer_global_5fextensions_2ffield_5foptions_2eproto_;
+const ::google::protobuf::EnumDescriptor* LogOption_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return LogOption_descriptor_;
+}
+bool LogOption_IsValid(int value) {
+  switch(value) {
+    case 1:
+    case 2:
+      return true;
+    default:
+      return false;
+  }
+}
+
+::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::FieldOptions,
+    ::google::protobuf::internal::EnumTypeTraits< ::bgs::protocol::LogOption, ::bgs::protocol::LogOption_IsValid>, 14, false >
+  log(kLogFieldNumber, static_cast< ::bgs::protocol::LogOption >(1));
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/global_extensions/field_options.pb.h b/src/server/proto/Client/global_extensions/field_options.pb.h
new file mode 100644
index 00000000000..3dce90f83f0
--- /dev/null
+++ b/src/server/proto/Client/global_extensions/field_options.pb.h
@@ -0,0 +1,95 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: global_extensions/field_options.proto
+
+#ifndef PROTOBUF_global_5fextensions_2ffield_5foptions_2eproto__INCLUDED
+#define PROTOBUF_global_5fextensions_2ffield_5foptions_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/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/generated_enum_reflection.h>
+#include "google/protobuf/descriptor.pb.h"
+#include "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
+void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
+
+
+enum LogOption {
+  HIDDEN = 1,
+  HEX = 2
+};
+TC_SHARED_API bool LogOption_IsValid(int value);
+const LogOption LogOption_MIN = HIDDEN;
+const LogOption LogOption_MAX = HEX;
+const int LogOption_ARRAYSIZE = LogOption_MAX + 1;
+
+TC_SHARED_API const ::google::protobuf::EnumDescriptor* LogOption_descriptor();
+inline const ::std::string& LogOption_Name(LogOption value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    LogOption_descriptor(), value);
+}
+inline bool LogOption_Parse(
+    const ::std::string& name, LogOption* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<LogOption>(
+    LogOption_descriptor(), name, value);
+}
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+static const int kLogFieldNumber = 50000;
+TC_SHARED_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::FieldOptions,
+    ::google::protobuf::internal::EnumTypeTraits< ::bgs::protocol::LogOption, ::bgs::protocol::LogOption_IsValid>, 14, false >
+  log;
+
+// ===================================================================
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::bgs::protocol::LogOption> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::LogOption>() {
+  return ::bgs::protocol::LogOption_descriptor();
+}
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_global_5fextensions_2ffield_5foptions_2eproto__INCLUDED
diff --git a/src/server/proto/Client/global_extensions/method_options.pb.cc b/src/server/proto/Client/global_extensions/method_options.pb.cc
new file mode 100644
index 00000000000..ad95780a845
--- /dev/null
+++ b/src/server/proto/Client/global_extensions/method_options.pb.cc
@@ -0,0 +1,96 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: global_extensions/method_options.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "global_extensions/method_options.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+
+namespace {
+
+
+}  // namespace
+
+
+void protobuf_AssignDesc_global_5fextensions_2fmethod_5foptions_2eproto() {
+  protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "global_extensions/method_options.proto");
+  GOOGLE_CHECK(file != NULL);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_global_5fextensions_2fmethod_5foptions_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_global_5fextensions_2fmethod_5foptions_2eproto() {
+}
+
+void protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n&global_extensions/method_options.proto"
+    "\022\014bgs.protocol\032 google/protobuf/descript"
+    "or.proto:3\n\tmethod_id\022\036.google.protobuf."
+    "MethodOptions\030\320\206\003 \001(\rB%\n\rbnet.protocolB\022"
+    "MethodOptionsProtoH\001", 180);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "global_extensions/method_options.proto", &protobuf_RegisterTypes);
+  ::google::protobuf::internal::ExtensionSet::RegisterExtension(
+    &::google::protobuf::MethodOptions::default_instance(),
+    50000, 13, false, false);
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_global_5fextensions_2fmethod_5foptions_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_global_5fextensions_2fmethod_5foptions_2eproto {
+  StaticDescriptorInitializer_global_5fextensions_2fmethod_5foptions_2eproto() {
+    protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eproto();
+  }
+} static_descriptor_initializer_global_5fextensions_2fmethod_5foptions_2eproto_;
+::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions,
+    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false >
+  method_id(kMethodIdFieldNumber, 0u);
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/global_extensions/method_options.pb.h b/src/server/proto/Client/global_extensions/method_options.pb.h
new file mode 100644
index 00000000000..68e13db4a4c
--- /dev/null
+++ b/src/server/proto/Client/global_extensions/method_options.pb.h
@@ -0,0 +1,70 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: global_extensions/method_options.proto
+
+#ifndef PROTOBUF_global_5fextensions_2fmethod_5foptions_2eproto__INCLUDED
+#define PROTOBUF_global_5fextensions_2fmethod_5foptions_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/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include "google/protobuf/descriptor.pb.h"
+#include "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eproto();
+void protobuf_AssignDesc_global_5fextensions_2fmethod_5foptions_2eproto();
+void protobuf_ShutdownFile_global_5fextensions_2fmethod_5foptions_2eproto();
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+static const int kMethodIdFieldNumber = 50000;
+TC_SHARED_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::MethodOptions,
+    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false >
+  method_id;
+
+// ===================================================================
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_global_5fextensions_2fmethod_5foptions_2eproto__INCLUDED
diff --git a/src/server/proto/Client/global_extensions/service_options.pb.cc b/src/server/proto/Client/global_extensions/service_options.pb.cc
new file mode 100644
index 00000000000..6bd0768c9a9
--- /dev/null
+++ b/src/server/proto/Client/global_extensions/service_options.pb.cc
@@ -0,0 +1,105 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: global_extensions/service_options.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "global_extensions/service_options.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+
+namespace {
+
+
+}  // namespace
+
+
+void protobuf_AssignDesc_global_5fextensions_2fservice_5foptions_2eproto() {
+  protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "global_extensions/service_options.proto");
+  GOOGLE_CHECK(file != NULL);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_global_5fextensions_2fservice_5foptions_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_global_5fextensions_2fservice_5foptions_2eproto() {
+}
+
+void protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\'global_extensions/service_options.prot"
+    "o\022\014bgs.protocol\032 google/protobuf/descrip"
+    "tor.proto:R\n(original_fully_qualified_de"
+    "scriptor_name\022\037.google.protobuf.ServiceO"
+    "ptions\030\351\007 \001(\t:5\n\nservice_id\022\037.google.pro"
+    "tobuf.ServiceOptions\030\320\206\003 \001(\rB&\n\rbnet.pro"
+    "tocolB\023ServiceOptionsProtoH\001", 268);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "global_extensions/service_options.proto", &protobuf_RegisterTypes);
+  ::google::protobuf::internal::ExtensionSet::RegisterExtension(
+    &::google::protobuf::ServiceOptions::default_instance(),
+    1001, 9, false, false);
+  ::google::protobuf::internal::ExtensionSet::RegisterExtension(
+    &::google::protobuf::ServiceOptions::default_instance(),
+    50000, 13, false, false);
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_global_5fextensions_2fservice_5foptions_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_global_5fextensions_2fservice_5foptions_2eproto {
+  StaticDescriptorInitializer_global_5fextensions_2fservice_5foptions_2eproto() {
+    protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto();
+  }
+} static_descriptor_initializer_global_5fextensions_2fservice_5foptions_2eproto_;
+const ::std::string original_fully_qualified_descriptor_name_default("");
+::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::ServiceOptions,
+    ::google::protobuf::internal::StringTypeTraits, 9, false >
+  original_fully_qualified_descriptor_name(kOriginalFullyQualifiedDescriptorNameFieldNumber, original_fully_qualified_descriptor_name_default);
+::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::ServiceOptions,
+    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false >
+  service_id(kServiceIdFieldNumber, 0u);
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/global_extensions/service_options.pb.h b/src/server/proto/Client/global_extensions/service_options.pb.h
new file mode 100644
index 00000000000..5188e246ea5
--- /dev/null
+++ b/src/server/proto/Client/global_extensions/service_options.pb.h
@@ -0,0 +1,74 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: global_extensions/service_options.proto
+
+#ifndef PROTOBUF_global_5fextensions_2fservice_5foptions_2eproto__INCLUDED
+#define PROTOBUF_global_5fextensions_2fservice_5foptions_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/repeated_field.h>
+#include <google/protobuf/extension_set.h>
+#include "google/protobuf/descriptor.pb.h"
+#include "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto();
+void protobuf_AssignDesc_global_5fextensions_2fservice_5foptions_2eproto();
+void protobuf_ShutdownFile_global_5fextensions_2fservice_5foptions_2eproto();
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+static const int kOriginalFullyQualifiedDescriptorNameFieldNumber = 1001;
+TC_SHARED_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::ServiceOptions,
+    ::google::protobuf::internal::StringTypeTraits, 9, false >
+  original_fully_qualified_descriptor_name;
+static const int kServiceIdFieldNumber = 50000;
+TC_SHARED_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::ServiceOptions,
+    ::google::protobuf::internal::PrimitiveTypeTraits< ::google::protobuf::uint32 >, 13, false >
+  service_id;
+
+// ===================================================================
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_global_5fextensions_2fservice_5foptions_2eproto__INCLUDED
diff --git a/src/server/proto/Client/invitation_types.pb.cc b/src/server/proto/Client/invitation_types.pb.cc
new file mode 100644
index 00000000000..f166d4bd280
--- /dev/null
+++ b/src/server/proto/Client/invitation_types.pb.cc
@@ -0,0 +1,3684 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: invitation_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "invitation_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+
+namespace {
+
+const ::google::protobuf::Descriptor* Invitation_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Invitation_reflection_ = NULL;
+const ::google::protobuf::Descriptor* InvitationSuggestion_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  InvitationSuggestion_reflection_ = NULL;
+const ::google::protobuf::Descriptor* InvitationTarget_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  InvitationTarget_reflection_ = NULL;
+const ::google::protobuf::Descriptor* InvitationParams_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  InvitationParams_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SendInvitationRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SendInvitationRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SendInvitationResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SendInvitationResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UpdateInvitationRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UpdateInvitationRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* GenericInvitationRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  GenericInvitationRequest_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_invitation_5ftypes_2eproto() {
+  protobuf_AddDesc_invitation_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "invitation_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  Invitation_descriptor_ = file->message_type(0);
+  static const int Invitation_offsets_[8] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, inviter_identity_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, invitee_identity_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, inviter_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, invitee_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, invitation_message_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, creation_time_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, expiration_time_),
+  };
+  Invitation_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Invitation_descriptor_,
+      Invitation::default_instance_,
+      Invitation_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, _unknown_fields_),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Invitation, _extensions_),
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Invitation));
+  InvitationSuggestion_descriptor_ = file->message_type(1);
+  static const int InvitationSuggestion_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, channel_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, suggester_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, suggestee_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, suggester_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, suggestee_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, suggester_account_id_),
+  };
+  InvitationSuggestion_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      InvitationSuggestion_descriptor_,
+      InvitationSuggestion::default_instance_,
+      InvitationSuggestion_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationSuggestion, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(InvitationSuggestion));
+  InvitationTarget_descriptor_ = file->message_type(2);
+  static const int InvitationTarget_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, identity_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, email_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, battle_tag_),
+  };
+  InvitationTarget_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      InvitationTarget_descriptor_,
+      InvitationTarget::default_instance_,
+      InvitationTarget_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, _unknown_fields_),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationTarget, _extensions_),
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(InvitationTarget));
+  InvitationParams_descriptor_ = file->message_type(3);
+  static const int InvitationParams_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationParams, invitation_message_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationParams, expiration_time_),
+  };
+  InvitationParams_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      InvitationParams_descriptor_,
+      InvitationParams::default_instance_,
+      InvitationParams_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationParams, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationParams, _unknown_fields_),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InvitationParams, _extensions_),
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(InvitationParams));
+  SendInvitationRequest_descriptor_ = file->message_type(4);
+  static const int SendInvitationRequest_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, agent_identity_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, target_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, params_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, agent_info_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, target_),
+  };
+  SendInvitationRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SendInvitationRequest_descriptor_,
+      SendInvitationRequest::default_instance_,
+      SendInvitationRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SendInvitationRequest));
+  SendInvitationResponse_descriptor_ = file->message_type(5);
+  static const int SendInvitationResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationResponse, invitation_),
+  };
+  SendInvitationResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SendInvitationResponse_descriptor_,
+      SendInvitationResponse::default_instance_,
+      SendInvitationResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendInvitationResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SendInvitationResponse));
+  UpdateInvitationRequest_descriptor_ = file->message_type(6);
+  static const int UpdateInvitationRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateInvitationRequest, agent_identity_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateInvitationRequest, invitation_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateInvitationRequest, params_),
+  };
+  UpdateInvitationRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UpdateInvitationRequest_descriptor_,
+      UpdateInvitationRequest::default_instance_,
+      UpdateInvitationRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateInvitationRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateInvitationRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UpdateInvitationRequest));
+  GenericInvitationRequest_descriptor_ = file->message_type(7);
+  static const int GenericInvitationRequest_offsets_[8] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, target_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, invitation_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, invitee_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, inviter_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, previous_role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, desired_role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, reason_),
+  };
+  GenericInvitationRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      GenericInvitationRequest_descriptor_,
+      GenericInvitationRequest::default_instance_,
+      GenericInvitationRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(GenericInvitationRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(GenericInvitationRequest));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_invitation_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Invitation_descriptor_, &Invitation::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    InvitationSuggestion_descriptor_, &InvitationSuggestion::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    InvitationTarget_descriptor_, &InvitationTarget::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    InvitationParams_descriptor_, &InvitationParams::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SendInvitationRequest_descriptor_, &SendInvitationRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SendInvitationResponse_descriptor_, &SendInvitationResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UpdateInvitationRequest_descriptor_, &UpdateInvitationRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    GenericInvitationRequest_descriptor_, &GenericInvitationRequest::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_invitation_5ftypes_2eproto() {
+  delete Invitation::default_instance_;
+  delete Invitation_reflection_;
+  delete InvitationSuggestion::default_instance_;
+  delete InvitationSuggestion_reflection_;
+  delete InvitationTarget::default_instance_;
+  delete InvitationTarget_reflection_;
+  delete InvitationParams::default_instance_;
+  delete InvitationParams_reflection_;
+  delete SendInvitationRequest::default_instance_;
+  delete SendInvitationRequest_reflection_;
+  delete SendInvitationResponse::default_instance_;
+  delete SendInvitationResponse_reflection_;
+  delete UpdateInvitationRequest::default_instance_;
+  delete UpdateInvitationRequest_reflection_;
+  delete GenericInvitationRequest::default_instance_;
+  delete GenericInvitationRequest_reflection_;
+}
+
+void protobuf_AddDesc_invitation_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\026invitation_types.proto\022\014bgs.protocol\032\022"
+    "entity_types.proto\"\373\001\n\nInvitation\022\n\n\002id\030"
+    "\001 \002(\006\0220\n\020inviter_identity\030\002 \002(\0132\026.bgs.pr"
+    "otocol.Identity\0220\n\020invitee_identity\030\003 \002("
+    "\0132\026.bgs.protocol.Identity\022\024\n\014inviter_nam"
+    "e\030\004 \001(\t\022\024\n\014invitee_name\030\005 \001(\t\022\032\n\022invitat"
+    "ion_message\030\006 \001(\t\022\025\n\rcreation_time\030\007 \001(\004"
+    "\022\027\n\017expiration_time\030\010 \001(\004*\005\010d\020\220N\"\204\002\n\024Inv"
+    "itationSuggestion\022*\n\nchannel_id\030\001 \001(\0132\026."
+    "bgs.protocol.EntityId\022,\n\014suggester_id\030\002 "
+    "\002(\0132\026.bgs.protocol.EntityId\022,\n\014suggestee"
+    "_id\030\003 \002(\0132\026.bgs.protocol.EntityId\022\026\n\016sug"
+    "gester_name\030\004 \001(\t\022\026\n\016suggestee_name\030\005 \001("
+    "\t\0224\n\024suggester_account_id\030\006 \001(\0132\026.bgs.pr"
+    "otocol.EntityId\"f\n\020InvitationTarget\022(\n\010i"
+    "dentity\030\001 \001(\0132\026.bgs.protocol.Identity\022\r\n"
+    "\005email\030\002 \001(\t\022\022\n\nbattle_tag\030\003 \001(\t*\005\010d\020\220N\""
+    "Q\n\020InvitationParams\022\032\n\022invitation_messag"
+    "e\030\001 \001(\t\022\032\n\017expiration_time\030\002 \001(\004:\0010*\005\010d\020"
+    "\220N\"\205\002\n\025SendInvitationRequest\022.\n\016agent_id"
+    "entity\030\001 \001(\0132\026.bgs.protocol.Identity\022-\n\t"
+    "target_id\030\002 \002(\0132\026.bgs.protocol.EntityIdB"
+    "\002\030\001\022.\n\006params\030\003 \002(\0132\036.bgs.protocol.Invit"
+    "ationParams\022-\n\nagent_info\030\004 \001(\0132\031.bgs.pr"
+    "otocol.AccountInfo\022.\n\006target\030\005 \001(\0132\036.bgs"
+    ".protocol.InvitationTarget\"F\n\026SendInvita"
+    "tionResponse\022,\n\ninvitation\030\002 \001(\0132\030.bgs.p"
+    "rotocol.Invitation\"\220\001\n\027UpdateInvitationR"
+    "equest\022.\n\016agent_identity\030\001 \001(\0132\026.bgs.pro"
+    "tocol.Identity\022\025\n\rinvitation_id\030\002 \002(\006\022.\n"
+    "\006params\030\003 \002(\0132\036.bgs.protocol.InvitationP"
+    "arams\"\367\001\n\030GenericInvitationRequest\022(\n\010ag"
+    "ent_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022)\n\t"
+    "target_id\030\002 \001(\0132\026.bgs.protocol.EntityId\022"
+    "\025\n\rinvitation_id\030\003 \002(\006\022\024\n\014invitee_name\030\004"
+    " \001(\t\022\024\n\014inviter_name\030\005 \001(\t\022\031\n\rprevious_r"
+    "ole\030\006 \003(\rB\002\020\001\022\030\n\014desired_role\030\007 \003(\rB\002\020\001\022"
+    "\016\n\006reason\030\010 \001(\rB\'\n\rbnet.protocolB\024Invita"
+    "tionTypesProtoH\001", 1536);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "invitation_types.proto", &protobuf_RegisterTypes);
+  Invitation::default_instance_ = new Invitation();
+  InvitationSuggestion::default_instance_ = new InvitationSuggestion();
+  InvitationTarget::default_instance_ = new InvitationTarget();
+  InvitationParams::default_instance_ = new InvitationParams();
+  SendInvitationRequest::default_instance_ = new SendInvitationRequest();
+  SendInvitationResponse::default_instance_ = new SendInvitationResponse();
+  UpdateInvitationRequest::default_instance_ = new UpdateInvitationRequest();
+  GenericInvitationRequest::default_instance_ = new GenericInvitationRequest();
+  Invitation::default_instance_->InitAsDefaultInstance();
+  InvitationSuggestion::default_instance_->InitAsDefaultInstance();
+  InvitationTarget::default_instance_->InitAsDefaultInstance();
+  InvitationParams::default_instance_->InitAsDefaultInstance();
+  SendInvitationRequest::default_instance_->InitAsDefaultInstance();
+  SendInvitationResponse::default_instance_->InitAsDefaultInstance();
+  UpdateInvitationRequest::default_instance_->InitAsDefaultInstance();
+  GenericInvitationRequest::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_invitation_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_invitation_5ftypes_2eproto {
+  StaticDescriptorInitializer_invitation_5ftypes_2eproto() {
+    protobuf_AddDesc_invitation_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_invitation_5ftypes_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Invitation::kIdFieldNumber;
+const int Invitation::kInviterIdentityFieldNumber;
+const int Invitation::kInviteeIdentityFieldNumber;
+const int Invitation::kInviterNameFieldNumber;
+const int Invitation::kInviteeNameFieldNumber;
+const int Invitation::kInvitationMessageFieldNumber;
+const int Invitation::kCreationTimeFieldNumber;
+const int Invitation::kExpirationTimeFieldNumber;
+#endif  // !_MSC_VER
+
+Invitation::Invitation()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.Invitation)
+}
+
+void Invitation::InitAsDefaultInstance() {
+  inviter_identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance());
+  invitee_identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance());
+}
+
+Invitation::Invitation(const Invitation& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.Invitation)
+}
+
+void Invitation::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = GOOGLE_ULONGLONG(0);
+  inviter_identity_ = NULL;
+  invitee_identity_ = NULL;
+  inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  invitation_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  expiration_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Invitation::~Invitation() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.Invitation)
+  SharedDtor();
+}
+
+void Invitation::SharedDtor() {
+  if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete inviter_name_;
+  }
+  if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete invitee_name_;
+  }
+  if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete invitation_message_;
+  }
+  if (this != default_instance_) {
+    delete inviter_identity_;
+    delete invitee_identity_;
+  }
+}
+
+void Invitation::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Invitation::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Invitation_descriptor_;
+}
+
+const Invitation& Invitation::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Invitation* Invitation::default_instance_ = NULL;
+
+Invitation* Invitation::New() const {
+  return new Invitation;
+}
+
+void Invitation::Clear() {
+  _extensions_.Clear();
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<Invitation*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 255) {
+    ZR_(creation_time_, expiration_time_);
+    id_ = GOOGLE_ULONGLONG(0);
+    if (has_inviter_identity()) {
+      if (inviter_identity_ != NULL) inviter_identity_->::bgs::protocol::Identity::Clear();
+    }
+    if (has_invitee_identity()) {
+      if (invitee_identity_ != NULL) invitee_identity_->::bgs::protocol::Identity::Clear();
+    }
+    if (has_inviter_name()) {
+      if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        inviter_name_->clear();
+      }
+    }
+    if (has_invitee_name()) {
+      if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        invitee_name_->clear();
+      }
+    }
+    if (has_invitation_message()) {
+      if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        invitation_message_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Invitation::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.Invitation)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required fixed64 id = 1;
+      case 1: {
+        if (tag == 9) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_inviter_identity;
+        break;
+      }
+
+      // required .bgs.protocol.Identity inviter_identity = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_inviter_identity:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_inviter_identity()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_invitee_identity;
+        break;
+      }
+
+      // required .bgs.protocol.Identity invitee_identity = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_invitee_identity:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_invitee_identity()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_inviter_name;
+        break;
+      }
+
+      // optional string inviter_name = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_inviter_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_inviter_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->inviter_name().data(), this->inviter_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "inviter_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_invitee_name;
+        break;
+      }
+
+      // optional string invitee_name = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_invitee_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_invitee_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->invitee_name().data(), this->invitee_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "invitee_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_invitation_message;
+        break;
+      }
+
+      // optional string invitation_message = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_invitation_message:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_invitation_message()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->invitation_message().data(), this->invitation_message().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "invitation_message");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_creation_time;
+        break;
+      }
+
+      // optional uint64 creation_time = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_creation_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &creation_time_)));
+          set_has_creation_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_expiration_time;
+        break;
+      }
+
+      // optional uint64 expiration_time = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_expiration_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &expiration_time_)));
+          set_has_expiration_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        if ((800u <= tag && tag < 80000u)) {
+          DO_(_extensions_.ParseField(tag, input, default_instance_,
+                                      mutable_unknown_fields()));
+          continue;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.Invitation)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.Invitation)
+  return false;
+#undef DO_
+}
+
+void Invitation::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.Invitation)
+  // required fixed64 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(1, this->id(), output);
+  }
+
+  // required .bgs.protocol.Identity inviter_identity = 2;
+  if (has_inviter_identity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->inviter_identity(), output);
+  }
+
+  // required .bgs.protocol.Identity invitee_identity = 3;
+  if (has_invitee_identity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->invitee_identity(), output);
+  }
+
+  // optional string inviter_name = 4;
+  if (has_inviter_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->inviter_name().data(), this->inviter_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "inviter_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->inviter_name(), output);
+  }
+
+  // optional string invitee_name = 5;
+  if (has_invitee_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->invitee_name().data(), this->invitee_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "invitee_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      5, this->invitee_name(), output);
+  }
+
+  // optional string invitation_message = 6;
+  if (has_invitation_message()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->invitation_message().data(), this->invitation_message().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "invitation_message");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      6, this->invitation_message(), output);
+  }
+
+  // optional uint64 creation_time = 7;
+  if (has_creation_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(7, this->creation_time(), output);
+  }
+
+  // optional uint64 expiration_time = 8;
+  if (has_expiration_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->expiration_time(), output);
+  }
+
+  // Extension range [100, 10000)
+  _extensions_.SerializeWithCachedSizes(
+      100, 10000, output);
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.Invitation)
+}
+
+::google::protobuf::uint8* Invitation::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Invitation)
+  // required fixed64 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(1, this->id(), target);
+  }
+
+  // required .bgs.protocol.Identity inviter_identity = 2;
+  if (has_inviter_identity()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->inviter_identity(), target);
+  }
+
+  // required .bgs.protocol.Identity invitee_identity = 3;
+  if (has_invitee_identity()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->invitee_identity(), target);
+  }
+
+  // optional string inviter_name = 4;
+  if (has_inviter_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->inviter_name().data(), this->inviter_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "inviter_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->inviter_name(), target);
+  }
+
+  // optional string invitee_name = 5;
+  if (has_invitee_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->invitee_name().data(), this->invitee_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "invitee_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->invitee_name(), target);
+  }
+
+  // optional string invitation_message = 6;
+  if (has_invitation_message()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->invitation_message().data(), this->invitation_message().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "invitation_message");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        6, this->invitation_message(), target);
+  }
+
+  // optional uint64 creation_time = 7;
+  if (has_creation_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(7, this->creation_time(), target);
+  }
+
+  // optional uint64 expiration_time = 8;
+  if (has_expiration_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->expiration_time(), target);
+  }
+
+  // Extension range [100, 10000)
+  target = _extensions_.SerializeWithCachedSizesToArray(
+      100, 10000, target);
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Invitation)
+  return target;
+}
+
+int Invitation::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required fixed64 id = 1;
+    if (has_id()) {
+      total_size += 1 + 8;
+    }
+
+    // required .bgs.protocol.Identity inviter_identity = 2;
+    if (has_inviter_identity()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->inviter_identity());
+    }
+
+    // required .bgs.protocol.Identity invitee_identity = 3;
+    if (has_invitee_identity()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->invitee_identity());
+    }
+
+    // optional string inviter_name = 4;
+    if (has_inviter_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->inviter_name());
+    }
+
+    // optional string invitee_name = 5;
+    if (has_invitee_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->invitee_name());
+    }
+
+    // optional string invitation_message = 6;
+    if (has_invitation_message()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->invitation_message());
+    }
+
+    // optional uint64 creation_time = 7;
+    if (has_creation_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->creation_time());
+    }
+
+    // optional uint64 expiration_time = 8;
+    if (has_expiration_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->expiration_time());
+    }
+
+  }
+  total_size += _extensions_.ByteSize();
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Invitation::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Invitation* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Invitation*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Invitation::MergeFrom(const Invitation& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_inviter_identity()) {
+      mutable_inviter_identity()->::bgs::protocol::Identity::MergeFrom(from.inviter_identity());
+    }
+    if (from.has_invitee_identity()) {
+      mutable_invitee_identity()->::bgs::protocol::Identity::MergeFrom(from.invitee_identity());
+    }
+    if (from.has_inviter_name()) {
+      set_inviter_name(from.inviter_name());
+    }
+    if (from.has_invitee_name()) {
+      set_invitee_name(from.invitee_name());
+    }
+    if (from.has_invitation_message()) {
+      set_invitation_message(from.invitation_message());
+    }
+    if (from.has_creation_time()) {
+      set_creation_time(from.creation_time());
+    }
+    if (from.has_expiration_time()) {
+      set_expiration_time(from.expiration_time());
+    }
+  }
+  _extensions_.MergeFrom(from._extensions_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Invitation::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Invitation::CopyFrom(const Invitation& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Invitation::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
+
+  if (has_inviter_identity()) {
+    if (!this->inviter_identity().IsInitialized()) return false;
+  }
+  if (has_invitee_identity()) {
+    if (!this->invitee_identity().IsInitialized()) return false;
+  }
+
+  if (!_extensions_.IsInitialized()) return false;  return true;
+}
+
+void Invitation::Swap(Invitation* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(inviter_identity_, other->inviter_identity_);
+    std::swap(invitee_identity_, other->invitee_identity_);
+    std::swap(inviter_name_, other->inviter_name_);
+    std::swap(invitee_name_, other->invitee_name_);
+    std::swap(invitation_message_, other->invitation_message_);
+    std::swap(creation_time_, other->creation_time_);
+    std::swap(expiration_time_, other->expiration_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+    _extensions_.Swap(&other->_extensions_);
+  }
+}
+
+::google::protobuf::Metadata Invitation::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Invitation_descriptor_;
+  metadata.reflection = Invitation_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int InvitationSuggestion::kChannelIdFieldNumber;
+const int InvitationSuggestion::kSuggesterIdFieldNumber;
+const int InvitationSuggestion::kSuggesteeIdFieldNumber;
+const int InvitationSuggestion::kSuggesterNameFieldNumber;
+const int InvitationSuggestion::kSuggesteeNameFieldNumber;
+const int InvitationSuggestion::kSuggesterAccountIdFieldNumber;
+#endif  // !_MSC_VER
+
+InvitationSuggestion::InvitationSuggestion()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.InvitationSuggestion)
+}
+
+void InvitationSuggestion::InitAsDefaultInstance() {
+  channel_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  suggester_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  suggestee_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  suggester_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+InvitationSuggestion::InvitationSuggestion(const InvitationSuggestion& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.InvitationSuggestion)
+}
+
+void InvitationSuggestion::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  channel_id_ = NULL;
+  suggester_id_ = NULL;
+  suggestee_id_ = NULL;
+  suggester_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  suggestee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  suggester_account_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+InvitationSuggestion::~InvitationSuggestion() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.InvitationSuggestion)
+  SharedDtor();
+}
+
+void InvitationSuggestion::SharedDtor() {
+  if (suggester_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete suggester_name_;
+  }
+  if (suggestee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete suggestee_name_;
+  }
+  if (this != default_instance_) {
+    delete channel_id_;
+    delete suggester_id_;
+    delete suggestee_id_;
+    delete suggester_account_id_;
+  }
+}
+
+void InvitationSuggestion::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* InvitationSuggestion::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return InvitationSuggestion_descriptor_;
+}
+
+const InvitationSuggestion& InvitationSuggestion::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+InvitationSuggestion* InvitationSuggestion::default_instance_ = NULL;
+
+InvitationSuggestion* InvitationSuggestion::New() const {
+  return new InvitationSuggestion;
+}
+
+void InvitationSuggestion::Clear() {
+  if (_has_bits_[0 / 32] & 63) {
+    if (has_channel_id()) {
+      if (channel_id_ != NULL) channel_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_suggester_id()) {
+      if (suggester_id_ != NULL) suggester_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_suggestee_id()) {
+      if (suggestee_id_ != NULL) suggestee_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_suggester_name()) {
+      if (suggester_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        suggester_name_->clear();
+      }
+    }
+    if (has_suggestee_name()) {
+      if (suggestee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        suggestee_name_->clear();
+      }
+    }
+    if (has_suggester_account_id()) {
+      if (suggester_account_id_ != NULL) suggester_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool InvitationSuggestion::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.InvitationSuggestion)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId channel_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_channel_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_suggester_id;
+        break;
+      }
+
+      // required .bgs.protocol.EntityId suggester_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_suggester_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_suggester_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_suggestee_id;
+        break;
+      }
+
+      // required .bgs.protocol.EntityId suggestee_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_suggestee_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_suggestee_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_suggester_name;
+        break;
+      }
+
+      // optional string suggester_name = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_suggester_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_suggester_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->suggester_name().data(), this->suggester_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "suggester_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_suggestee_name;
+        break;
+      }
+
+      // optional string suggestee_name = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_suggestee_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_suggestee_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->suggestee_name().data(), this->suggestee_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "suggestee_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_suggester_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId suggester_account_id = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_suggester_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_suggester_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.InvitationSuggestion)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.InvitationSuggestion)
+  return false;
+#undef DO_
+}
+
+void InvitationSuggestion::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.InvitationSuggestion)
+  // optional .bgs.protocol.EntityId channel_id = 1;
+  if (has_channel_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->channel_id(), output);
+  }
+
+  // required .bgs.protocol.EntityId suggester_id = 2;
+  if (has_suggester_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->suggester_id(), output);
+  }
+
+  // required .bgs.protocol.EntityId suggestee_id = 3;
+  if (has_suggestee_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->suggestee_id(), output);
+  }
+
+  // optional string suggester_name = 4;
+  if (has_suggester_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->suggester_name().data(), this->suggester_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "suggester_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->suggester_name(), output);
+  }
+
+  // optional string suggestee_name = 5;
+  if (has_suggestee_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->suggestee_name().data(), this->suggestee_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "suggestee_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      5, this->suggestee_name(), output);
+  }
+
+  // optional .bgs.protocol.EntityId suggester_account_id = 6;
+  if (has_suggester_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->suggester_account_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.InvitationSuggestion)
+}
+
+::google::protobuf::uint8* InvitationSuggestion::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.InvitationSuggestion)
+  // optional .bgs.protocol.EntityId channel_id = 1;
+  if (has_channel_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->channel_id(), target);
+  }
+
+  // required .bgs.protocol.EntityId suggester_id = 2;
+  if (has_suggester_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->suggester_id(), target);
+  }
+
+  // required .bgs.protocol.EntityId suggestee_id = 3;
+  if (has_suggestee_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->suggestee_id(), target);
+  }
+
+  // optional string suggester_name = 4;
+  if (has_suggester_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->suggester_name().data(), this->suggester_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "suggester_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->suggester_name(), target);
+  }
+
+  // optional string suggestee_name = 5;
+  if (has_suggestee_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->suggestee_name().data(), this->suggestee_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "suggestee_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->suggestee_name(), target);
+  }
+
+  // optional .bgs.protocol.EntityId suggester_account_id = 6;
+  if (has_suggester_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->suggester_account_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.InvitationSuggestion)
+  return target;
+}
+
+int InvitationSuggestion::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId channel_id = 1;
+    if (has_channel_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->channel_id());
+    }
+
+    // required .bgs.protocol.EntityId suggester_id = 2;
+    if (has_suggester_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->suggester_id());
+    }
+
+    // required .bgs.protocol.EntityId suggestee_id = 3;
+    if (has_suggestee_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->suggestee_id());
+    }
+
+    // optional string suggester_name = 4;
+    if (has_suggester_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->suggester_name());
+    }
+
+    // optional string suggestee_name = 5;
+    if (has_suggestee_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->suggestee_name());
+    }
+
+    // optional .bgs.protocol.EntityId suggester_account_id = 6;
+    if (has_suggester_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->suggester_account_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void InvitationSuggestion::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const InvitationSuggestion* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const InvitationSuggestion*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void InvitationSuggestion::MergeFrom(const InvitationSuggestion& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_channel_id()) {
+      mutable_channel_id()->::bgs::protocol::EntityId::MergeFrom(from.channel_id());
+    }
+    if (from.has_suggester_id()) {
+      mutable_suggester_id()->::bgs::protocol::EntityId::MergeFrom(from.suggester_id());
+    }
+    if (from.has_suggestee_id()) {
+      mutable_suggestee_id()->::bgs::protocol::EntityId::MergeFrom(from.suggestee_id());
+    }
+    if (from.has_suggester_name()) {
+      set_suggester_name(from.suggester_name());
+    }
+    if (from.has_suggestee_name()) {
+      set_suggestee_name(from.suggestee_name());
+    }
+    if (from.has_suggester_account_id()) {
+      mutable_suggester_account_id()->::bgs::protocol::EntityId::MergeFrom(from.suggester_account_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void InvitationSuggestion::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void InvitationSuggestion::CopyFrom(const InvitationSuggestion& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool InvitationSuggestion::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false;
+
+  if (has_channel_id()) {
+    if (!this->channel_id().IsInitialized()) return false;
+  }
+  if (has_suggester_id()) {
+    if (!this->suggester_id().IsInitialized()) return false;
+  }
+  if (has_suggestee_id()) {
+    if (!this->suggestee_id().IsInitialized()) return false;
+  }
+  if (has_suggester_account_id()) {
+    if (!this->suggester_account_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void InvitationSuggestion::Swap(InvitationSuggestion* other) {
+  if (other != this) {
+    std::swap(channel_id_, other->channel_id_);
+    std::swap(suggester_id_, other->suggester_id_);
+    std::swap(suggestee_id_, other->suggestee_id_);
+    std::swap(suggester_name_, other->suggester_name_);
+    std::swap(suggestee_name_, other->suggestee_name_);
+    std::swap(suggester_account_id_, other->suggester_account_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata InvitationSuggestion::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = InvitationSuggestion_descriptor_;
+  metadata.reflection = InvitationSuggestion_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int InvitationTarget::kIdentityFieldNumber;
+const int InvitationTarget::kEmailFieldNumber;
+const int InvitationTarget::kBattleTagFieldNumber;
+#endif  // !_MSC_VER
+
+InvitationTarget::InvitationTarget()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.InvitationTarget)
+}
+
+void InvitationTarget::InitAsDefaultInstance() {
+  identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance());
+}
+
+InvitationTarget::InvitationTarget(const InvitationTarget& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.InvitationTarget)
+}
+
+void InvitationTarget::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  identity_ = NULL;
+  email_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+InvitationTarget::~InvitationTarget() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.InvitationTarget)
+  SharedDtor();
+}
+
+void InvitationTarget::SharedDtor() {
+  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete email_;
+  }
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete battle_tag_;
+  }
+  if (this != default_instance_) {
+    delete identity_;
+  }
+}
+
+void InvitationTarget::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* InvitationTarget::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return InvitationTarget_descriptor_;
+}
+
+const InvitationTarget& InvitationTarget::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+InvitationTarget* InvitationTarget::default_instance_ = NULL;
+
+InvitationTarget* InvitationTarget::New() const {
+  return new InvitationTarget;
+}
+
+void InvitationTarget::Clear() {
+  _extensions_.Clear();
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_identity()) {
+      if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear();
+    }
+    if (has_email()) {
+      if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        email_->clear();
+      }
+    }
+    if (has_battle_tag()) {
+      if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        battle_tag_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool InvitationTarget::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.InvitationTarget)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.Identity identity = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_identity()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_email;
+        break;
+      }
+
+      // optional string email = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_email:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_email()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->email().data(), this->email().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "email");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_battle_tag;
+        break;
+      }
+
+      // optional string battle_tag = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_battle_tag:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_battle_tag()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->battle_tag().data(), this->battle_tag().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "battle_tag");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        if ((800u <= tag && tag < 80000u)) {
+          DO_(_extensions_.ParseField(tag, input, default_instance_,
+                                      mutable_unknown_fields()));
+          continue;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.InvitationTarget)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.InvitationTarget)
+  return false;
+#undef DO_
+}
+
+void InvitationTarget::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.InvitationTarget)
+  // optional .bgs.protocol.Identity identity = 1;
+  if (has_identity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->identity(), output);
+  }
+
+  // optional string email = 2;
+  if (has_email()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->email().data(), this->email().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "email");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->email(), output);
+  }
+
+  // optional string battle_tag = 3;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->battle_tag(), output);
+  }
+
+  // Extension range [100, 10000)
+  _extensions_.SerializeWithCachedSizes(
+      100, 10000, output);
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.InvitationTarget)
+}
+
+::google::protobuf::uint8* InvitationTarget::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.InvitationTarget)
+  // optional .bgs.protocol.Identity identity = 1;
+  if (has_identity()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->identity(), target);
+  }
+
+  // optional string email = 2;
+  if (has_email()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->email().data(), this->email().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "email");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->email(), target);
+  }
+
+  // optional string battle_tag = 3;
+  if (has_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->battle_tag().data(), this->battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "battle_tag");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->battle_tag(), target);
+  }
+
+  // Extension range [100, 10000)
+  target = _extensions_.SerializeWithCachedSizesToArray(
+      100, 10000, target);
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.InvitationTarget)
+  return target;
+}
+
+int InvitationTarget::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.Identity identity = 1;
+    if (has_identity()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->identity());
+    }
+
+    // optional string email = 2;
+    if (has_email()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->email());
+    }
+
+    // optional string battle_tag = 3;
+    if (has_battle_tag()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->battle_tag());
+    }
+
+  }
+  total_size += _extensions_.ByteSize();
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void InvitationTarget::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const InvitationTarget* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const InvitationTarget*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void InvitationTarget::MergeFrom(const InvitationTarget& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_identity()) {
+      mutable_identity()->::bgs::protocol::Identity::MergeFrom(from.identity());
+    }
+    if (from.has_email()) {
+      set_email(from.email());
+    }
+    if (from.has_battle_tag()) {
+      set_battle_tag(from.battle_tag());
+    }
+  }
+  _extensions_.MergeFrom(from._extensions_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void InvitationTarget::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void InvitationTarget::CopyFrom(const InvitationTarget& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool InvitationTarget::IsInitialized() const {
+
+  if (has_identity()) {
+    if (!this->identity().IsInitialized()) return false;
+  }
+
+  if (!_extensions_.IsInitialized()) return false;  return true;
+}
+
+void InvitationTarget::Swap(InvitationTarget* other) {
+  if (other != this) {
+    std::swap(identity_, other->identity_);
+    std::swap(email_, other->email_);
+    std::swap(battle_tag_, other->battle_tag_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+    _extensions_.Swap(&other->_extensions_);
+  }
+}
+
+::google::protobuf::Metadata InvitationTarget::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = InvitationTarget_descriptor_;
+  metadata.reflection = InvitationTarget_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int InvitationParams::kInvitationMessageFieldNumber;
+const int InvitationParams::kExpirationTimeFieldNumber;
+#endif  // !_MSC_VER
+
+InvitationParams::InvitationParams()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.InvitationParams)
+}
+
+void InvitationParams::InitAsDefaultInstance() {
+}
+
+InvitationParams::InvitationParams(const InvitationParams& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.InvitationParams)
+}
+
+void InvitationParams::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  invitation_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  expiration_time_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+InvitationParams::~InvitationParams() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.InvitationParams)
+  SharedDtor();
+}
+
+void InvitationParams::SharedDtor() {
+  if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete invitation_message_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void InvitationParams::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* InvitationParams::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return InvitationParams_descriptor_;
+}
+
+const InvitationParams& InvitationParams::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+InvitationParams* InvitationParams::default_instance_ = NULL;
+
+InvitationParams* InvitationParams::New() const {
+  return new InvitationParams;
+}
+
+void InvitationParams::Clear() {
+  _extensions_.Clear();
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_invitation_message()) {
+      if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        invitation_message_->clear();
+      }
+    }
+    expiration_time_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool InvitationParams::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.InvitationParams)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string invitation_message = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_invitation_message()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->invitation_message().data(), this->invitation_message().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "invitation_message");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_expiration_time;
+        break;
+      }
+
+      // optional uint64 expiration_time = 2 [default = 0];
+      case 2: {
+        if (tag == 16) {
+         parse_expiration_time:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &expiration_time_)));
+          set_has_expiration_time();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        if ((800u <= tag && tag < 80000u)) {
+          DO_(_extensions_.ParseField(tag, input, default_instance_,
+                                      mutable_unknown_fields()));
+          continue;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.InvitationParams)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.InvitationParams)
+  return false;
+#undef DO_
+}
+
+void InvitationParams::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.InvitationParams)
+  // optional string invitation_message = 1;
+  if (has_invitation_message()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->invitation_message().data(), this->invitation_message().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "invitation_message");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->invitation_message(), output);
+  }
+
+  // optional uint64 expiration_time = 2 [default = 0];
+  if (has_expiration_time()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->expiration_time(), output);
+  }
+
+  // Extension range [100, 10000)
+  _extensions_.SerializeWithCachedSizes(
+      100, 10000, output);
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.InvitationParams)
+}
+
+::google::protobuf::uint8* InvitationParams::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.InvitationParams)
+  // optional string invitation_message = 1;
+  if (has_invitation_message()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->invitation_message().data(), this->invitation_message().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "invitation_message");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->invitation_message(), target);
+  }
+
+  // optional uint64 expiration_time = 2 [default = 0];
+  if (has_expiration_time()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->expiration_time(), target);
+  }
+
+  // Extension range [100, 10000)
+  target = _extensions_.SerializeWithCachedSizesToArray(
+      100, 10000, target);
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.InvitationParams)
+  return target;
+}
+
+int InvitationParams::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string invitation_message = 1;
+    if (has_invitation_message()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->invitation_message());
+    }
+
+    // optional uint64 expiration_time = 2 [default = 0];
+    if (has_expiration_time()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->expiration_time());
+    }
+
+  }
+  total_size += _extensions_.ByteSize();
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void InvitationParams::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const InvitationParams* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const InvitationParams*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void InvitationParams::MergeFrom(const InvitationParams& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_invitation_message()) {
+      set_invitation_message(from.invitation_message());
+    }
+    if (from.has_expiration_time()) {
+      set_expiration_time(from.expiration_time());
+    }
+  }
+  _extensions_.MergeFrom(from._extensions_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void InvitationParams::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void InvitationParams::CopyFrom(const InvitationParams& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool InvitationParams::IsInitialized() const {
+
+
+  if (!_extensions_.IsInitialized()) return false;  return true;
+}
+
+void InvitationParams::Swap(InvitationParams* other) {
+  if (other != this) {
+    std::swap(invitation_message_, other->invitation_message_);
+    std::swap(expiration_time_, other->expiration_time_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+    _extensions_.Swap(&other->_extensions_);
+  }
+}
+
+::google::protobuf::Metadata InvitationParams::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = InvitationParams_descriptor_;
+  metadata.reflection = InvitationParams_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SendInvitationRequest::kAgentIdentityFieldNumber;
+const int SendInvitationRequest::kTargetIdFieldNumber;
+const int SendInvitationRequest::kParamsFieldNumber;
+const int SendInvitationRequest::kAgentInfoFieldNumber;
+const int SendInvitationRequest::kTargetFieldNumber;
+#endif  // !_MSC_VER
+
+SendInvitationRequest::SendInvitationRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.SendInvitationRequest)
+}
+
+void SendInvitationRequest::InitAsDefaultInstance() {
+  agent_identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance());
+  target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  params_ = const_cast< ::bgs::protocol::InvitationParams*>(&::bgs::protocol::InvitationParams::default_instance());
+  agent_info_ = const_cast< ::bgs::protocol::AccountInfo*>(&::bgs::protocol::AccountInfo::default_instance());
+  target_ = const_cast< ::bgs::protocol::InvitationTarget*>(&::bgs::protocol::InvitationTarget::default_instance());
+}
+
+SendInvitationRequest::SendInvitationRequest(const SendInvitationRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.SendInvitationRequest)
+}
+
+void SendInvitationRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_identity_ = NULL;
+  target_id_ = NULL;
+  params_ = NULL;
+  agent_info_ = NULL;
+  target_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SendInvitationRequest::~SendInvitationRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.SendInvitationRequest)
+  SharedDtor();
+}
+
+void SendInvitationRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_identity_;
+    delete target_id_;
+    delete params_;
+    delete agent_info_;
+    delete target_;
+  }
+}
+
+void SendInvitationRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SendInvitationRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SendInvitationRequest_descriptor_;
+}
+
+const SendInvitationRequest& SendInvitationRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+SendInvitationRequest* SendInvitationRequest::default_instance_ = NULL;
+
+SendInvitationRequest* SendInvitationRequest::New() const {
+  return new SendInvitationRequest;
+}
+
+void SendInvitationRequest::Clear() {
+  if (_has_bits_[0 / 32] & 31) {
+    if (has_agent_identity()) {
+      if (agent_identity_ != NULL) agent_identity_->::bgs::protocol::Identity::Clear();
+    }
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_params()) {
+      if (params_ != NULL) params_->::bgs::protocol::InvitationParams::Clear();
+    }
+    if (has_agent_info()) {
+      if (agent_info_ != NULL) agent_info_->::bgs::protocol::AccountInfo::Clear();
+    }
+    if (has_target()) {
+      if (target_ != NULL) target_->::bgs::protocol::InvitationTarget::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SendInvitationRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.SendInvitationRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.Identity agent_identity = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_identity()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_target_id;
+        break;
+      }
+
+      // required .bgs.protocol.EntityId target_id = 2 [deprecated = true];
+      case 2: {
+        if (tag == 18) {
+         parse_target_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_params;
+        break;
+      }
+
+      // required .bgs.protocol.InvitationParams params = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_params:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_params()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_agent_info;
+        break;
+      }
+
+      // optional .bgs.protocol.AccountInfo agent_info = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_agent_info:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_info()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_target;
+        break;
+      }
+
+      // optional .bgs.protocol.InvitationTarget target = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_target:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.SendInvitationRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.SendInvitationRequest)
+  return false;
+#undef DO_
+}
+
+void SendInvitationRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.SendInvitationRequest)
+  // optional .bgs.protocol.Identity agent_identity = 1;
+  if (has_agent_identity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_identity(), output);
+  }
+
+  // required .bgs.protocol.EntityId target_id = 2 [deprecated = true];
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->target_id(), output);
+  }
+
+  // required .bgs.protocol.InvitationParams params = 3;
+  if (has_params()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->params(), output);
+  }
+
+  // optional .bgs.protocol.AccountInfo agent_info = 4;
+  if (has_agent_info()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->agent_info(), output);
+  }
+
+  // optional .bgs.protocol.InvitationTarget target = 5;
+  if (has_target()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->target(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.SendInvitationRequest)
+}
+
+::google::protobuf::uint8* SendInvitationRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.SendInvitationRequest)
+  // optional .bgs.protocol.Identity agent_identity = 1;
+  if (has_agent_identity()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_identity(), target);
+  }
+
+  // required .bgs.protocol.EntityId target_id = 2 [deprecated = true];
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->target_id(), target);
+  }
+
+  // required .bgs.protocol.InvitationParams params = 3;
+  if (has_params()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->params(), target);
+  }
+
+  // optional .bgs.protocol.AccountInfo agent_info = 4;
+  if (has_agent_info()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->agent_info(), target);
+  }
+
+  // optional .bgs.protocol.InvitationTarget target = 5;
+  if (has_target()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->target(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.SendInvitationRequest)
+  return target;
+}
+
+int SendInvitationRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.Identity agent_identity = 1;
+    if (has_agent_identity()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_identity());
+    }
+
+    // required .bgs.protocol.EntityId target_id = 2 [deprecated = true];
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+    // required .bgs.protocol.InvitationParams params = 3;
+    if (has_params()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->params());
+    }
+
+    // optional .bgs.protocol.AccountInfo agent_info = 4;
+    if (has_agent_info()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_info());
+    }
+
+    // optional .bgs.protocol.InvitationTarget target = 5;
+    if (has_target()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SendInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SendInvitationRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SendInvitationRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SendInvitationRequest::MergeFrom(const SendInvitationRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_identity()) {
+      mutable_agent_identity()->::bgs::protocol::Identity::MergeFrom(from.agent_identity());
+    }
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id());
+    }
+    if (from.has_params()) {
+      mutable_params()->::bgs::protocol::InvitationParams::MergeFrom(from.params());
+    }
+    if (from.has_agent_info()) {
+      mutable_agent_info()->::bgs::protocol::AccountInfo::MergeFrom(from.agent_info());
+    }
+    if (from.has_target()) {
+      mutable_target()->::bgs::protocol::InvitationTarget::MergeFrom(from.target());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SendInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SendInvitationRequest::CopyFrom(const SendInvitationRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SendInvitationRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false;
+
+  if (has_agent_identity()) {
+    if (!this->agent_identity().IsInitialized()) return false;
+  }
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  if (has_params()) {
+    if (!this->params().IsInitialized()) return false;
+  }
+  if (has_agent_info()) {
+    if (!this->agent_info().IsInitialized()) return false;
+  }
+  if (has_target()) {
+    if (!this->target().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SendInvitationRequest::Swap(SendInvitationRequest* other) {
+  if (other != this) {
+    std::swap(agent_identity_, other->agent_identity_);
+    std::swap(target_id_, other->target_id_);
+    std::swap(params_, other->params_);
+    std::swap(agent_info_, other->agent_info_);
+    std::swap(target_, other->target_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SendInvitationRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SendInvitationRequest_descriptor_;
+  metadata.reflection = SendInvitationRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SendInvitationResponse::kInvitationFieldNumber;
+#endif  // !_MSC_VER
+
+SendInvitationResponse::SendInvitationResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.SendInvitationResponse)
+}
+
+void SendInvitationResponse::InitAsDefaultInstance() {
+  invitation_ = const_cast< ::bgs::protocol::Invitation*>(&::bgs::protocol::Invitation::default_instance());
+}
+
+SendInvitationResponse::SendInvitationResponse(const SendInvitationResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.SendInvitationResponse)
+}
+
+void SendInvitationResponse::SharedCtor() {
+  _cached_size_ = 0;
+  invitation_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SendInvitationResponse::~SendInvitationResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.SendInvitationResponse)
+  SharedDtor();
+}
+
+void SendInvitationResponse::SharedDtor() {
+  if (this != default_instance_) {
+    delete invitation_;
+  }
+}
+
+void SendInvitationResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SendInvitationResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SendInvitationResponse_descriptor_;
+}
+
+const SendInvitationResponse& SendInvitationResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+SendInvitationResponse* SendInvitationResponse::default_instance_ = NULL;
+
+SendInvitationResponse* SendInvitationResponse::New() const {
+  return new SendInvitationResponse;
+}
+
+void SendInvitationResponse::Clear() {
+  if (has_invitation()) {
+    if (invitation_ != NULL) invitation_->::bgs::protocol::Invitation::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SendInvitationResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.SendInvitationResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.Invitation invitation = 2;
+      case 2: {
+        if (tag == 18) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_invitation()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.SendInvitationResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.SendInvitationResponse)
+  return false;
+#undef DO_
+}
+
+void SendInvitationResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.SendInvitationResponse)
+  // optional .bgs.protocol.Invitation invitation = 2;
+  if (has_invitation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->invitation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.SendInvitationResponse)
+}
+
+::google::protobuf::uint8* SendInvitationResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.SendInvitationResponse)
+  // optional .bgs.protocol.Invitation invitation = 2;
+  if (has_invitation()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->invitation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.SendInvitationResponse)
+  return target;
+}
+
+int SendInvitationResponse::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.Invitation invitation = 2;
+    if (has_invitation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->invitation());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SendInvitationResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SendInvitationResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SendInvitationResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SendInvitationResponse::MergeFrom(const SendInvitationResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_invitation()) {
+      mutable_invitation()->::bgs::protocol::Invitation::MergeFrom(from.invitation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SendInvitationResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SendInvitationResponse::CopyFrom(const SendInvitationResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SendInvitationResponse::IsInitialized() const {
+
+  if (has_invitation()) {
+    if (!this->invitation().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SendInvitationResponse::Swap(SendInvitationResponse* other) {
+  if (other != this) {
+    std::swap(invitation_, other->invitation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SendInvitationResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SendInvitationResponse_descriptor_;
+  metadata.reflection = SendInvitationResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UpdateInvitationRequest::kAgentIdentityFieldNumber;
+const int UpdateInvitationRequest::kInvitationIdFieldNumber;
+const int UpdateInvitationRequest::kParamsFieldNumber;
+#endif  // !_MSC_VER
+
+UpdateInvitationRequest::UpdateInvitationRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.UpdateInvitationRequest)
+}
+
+void UpdateInvitationRequest::InitAsDefaultInstance() {
+  agent_identity_ = const_cast< ::bgs::protocol::Identity*>(&::bgs::protocol::Identity::default_instance());
+  params_ = const_cast< ::bgs::protocol::InvitationParams*>(&::bgs::protocol::InvitationParams::default_instance());
+}
+
+UpdateInvitationRequest::UpdateInvitationRequest(const UpdateInvitationRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.UpdateInvitationRequest)
+}
+
+void UpdateInvitationRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_identity_ = NULL;
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  params_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UpdateInvitationRequest::~UpdateInvitationRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.UpdateInvitationRequest)
+  SharedDtor();
+}
+
+void UpdateInvitationRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_identity_;
+    delete params_;
+  }
+}
+
+void UpdateInvitationRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UpdateInvitationRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UpdateInvitationRequest_descriptor_;
+}
+
+const UpdateInvitationRequest& UpdateInvitationRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+UpdateInvitationRequest* UpdateInvitationRequest::default_instance_ = NULL;
+
+UpdateInvitationRequest* UpdateInvitationRequest::New() const {
+  return new UpdateInvitationRequest;
+}
+
+void UpdateInvitationRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_identity()) {
+      if (agent_identity_ != NULL) agent_identity_->::bgs::protocol::Identity::Clear();
+    }
+    invitation_id_ = GOOGLE_ULONGLONG(0);
+    if (has_params()) {
+      if (params_ != NULL) params_->::bgs::protocol::InvitationParams::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UpdateInvitationRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.UpdateInvitationRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.Identity agent_identity = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_identity()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(17)) goto parse_invitation_id;
+        break;
+      }
+
+      // required fixed64 invitation_id = 2;
+      case 2: {
+        if (tag == 17) {
+         parse_invitation_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &invitation_id_)));
+          set_has_invitation_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_params;
+        break;
+      }
+
+      // required .bgs.protocol.InvitationParams params = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_params:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_params()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.UpdateInvitationRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.UpdateInvitationRequest)
+  return false;
+#undef DO_
+}
+
+void UpdateInvitationRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.UpdateInvitationRequest)
+  // optional .bgs.protocol.Identity agent_identity = 1;
+  if (has_agent_identity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_identity(), output);
+  }
+
+  // required fixed64 invitation_id = 2;
+  if (has_invitation_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(2, this->invitation_id(), output);
+  }
+
+  // required .bgs.protocol.InvitationParams params = 3;
+  if (has_params()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->params(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.UpdateInvitationRequest)
+}
+
+::google::protobuf::uint8* UpdateInvitationRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.UpdateInvitationRequest)
+  // optional .bgs.protocol.Identity agent_identity = 1;
+  if (has_agent_identity()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_identity(), target);
+  }
+
+  // required fixed64 invitation_id = 2;
+  if (has_invitation_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(2, this->invitation_id(), target);
+  }
+
+  // required .bgs.protocol.InvitationParams params = 3;
+  if (has_params()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->params(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.UpdateInvitationRequest)
+  return target;
+}
+
+int UpdateInvitationRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.Identity agent_identity = 1;
+    if (has_agent_identity()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_identity());
+    }
+
+    // required fixed64 invitation_id = 2;
+    if (has_invitation_id()) {
+      total_size += 1 + 8;
+    }
+
+    // required .bgs.protocol.InvitationParams params = 3;
+    if (has_params()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->params());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UpdateInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UpdateInvitationRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateInvitationRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UpdateInvitationRequest::MergeFrom(const UpdateInvitationRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_identity()) {
+      mutable_agent_identity()->::bgs::protocol::Identity::MergeFrom(from.agent_identity());
+    }
+    if (from.has_invitation_id()) {
+      set_invitation_id(from.invitation_id());
+    }
+    if (from.has_params()) {
+      mutable_params()->::bgs::protocol::InvitationParams::MergeFrom(from.params());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UpdateInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UpdateInvitationRequest::CopyFrom(const UpdateInvitationRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UpdateInvitationRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false;
+
+  if (has_agent_identity()) {
+    if (!this->agent_identity().IsInitialized()) return false;
+  }
+  if (has_params()) {
+    if (!this->params().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UpdateInvitationRequest::Swap(UpdateInvitationRequest* other) {
+  if (other != this) {
+    std::swap(agent_identity_, other->agent_identity_);
+    std::swap(invitation_id_, other->invitation_id_);
+    std::swap(params_, other->params_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UpdateInvitationRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UpdateInvitationRequest_descriptor_;
+  metadata.reflection = UpdateInvitationRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int GenericInvitationRequest::kAgentIdFieldNumber;
+const int GenericInvitationRequest::kTargetIdFieldNumber;
+const int GenericInvitationRequest::kInvitationIdFieldNumber;
+const int GenericInvitationRequest::kInviteeNameFieldNumber;
+const int GenericInvitationRequest::kInviterNameFieldNumber;
+const int GenericInvitationRequest::kPreviousRoleFieldNumber;
+const int GenericInvitationRequest::kDesiredRoleFieldNumber;
+const int GenericInvitationRequest::kReasonFieldNumber;
+#endif  // !_MSC_VER
+
+GenericInvitationRequest::GenericInvitationRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.GenericInvitationRequest)
+}
+
+void GenericInvitationRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+GenericInvitationRequest::GenericInvitationRequest(const GenericInvitationRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.GenericInvitationRequest)
+}
+
+void GenericInvitationRequest::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  target_id_ = NULL;
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  reason_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+GenericInvitationRequest::~GenericInvitationRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.GenericInvitationRequest)
+  SharedDtor();
+}
+
+void GenericInvitationRequest::SharedDtor() {
+  if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete invitee_name_;
+  }
+  if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete inviter_name_;
+  }
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete target_id_;
+  }
+}
+
+void GenericInvitationRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* GenericInvitationRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return GenericInvitationRequest_descriptor_;
+}
+
+const GenericInvitationRequest& GenericInvitationRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_invitation_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+GenericInvitationRequest* GenericInvitationRequest::default_instance_ = NULL;
+
+GenericInvitationRequest* GenericInvitationRequest::New() const {
+  return new GenericInvitationRequest;
+}
+
+void GenericInvitationRequest::Clear() {
+  if (_has_bits_[0 / 32] & 159) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+    }
+    invitation_id_ = GOOGLE_ULONGLONG(0);
+    if (has_invitee_name()) {
+      if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        invitee_name_->clear();
+      }
+    }
+    if (has_inviter_name()) {
+      if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        inviter_name_->clear();
+      }
+    }
+    reason_ = 0u;
+  }
+  previous_role_.Clear();
+  desired_role_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool GenericInvitationRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.GenericInvitationRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_target_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId target_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_target_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(25)) goto parse_invitation_id;
+        break;
+      }
+
+      // required fixed64 invitation_id = 3;
+      case 3: {
+        if (tag == 25) {
+         parse_invitation_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &invitation_id_)));
+          set_has_invitation_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_invitee_name;
+        break;
+      }
+
+      // optional string invitee_name = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_invitee_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_invitee_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->invitee_name().data(), this->invitee_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "invitee_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_inviter_name;
+        break;
+      }
+
+      // optional string inviter_name = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_inviter_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_inviter_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->inviter_name().data(), this->inviter_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "inviter_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_previous_role;
+        break;
+      }
+
+      // repeated uint32 previous_role = 6 [packed = true];
+      case 6: {
+        if (tag == 50) {
+         parse_previous_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_previous_role())));
+        } else if (tag == 48) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 50, input, this->mutable_previous_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_desired_role;
+        break;
+      }
+
+      // repeated uint32 desired_role = 7 [packed = true];
+      case 7: {
+        if (tag == 58) {
+         parse_desired_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_desired_role())));
+        } else if (tag == 56) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 58, input, this->mutable_desired_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_reason;
+        break;
+      }
+
+      // optional uint32 reason = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_reason:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &reason_)));
+          set_has_reason();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.GenericInvitationRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.GenericInvitationRequest)
+  return false;
+#undef DO_
+}
+
+void GenericInvitationRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.GenericInvitationRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->target_id(), output);
+  }
+
+  // required fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->invitation_id(), output);
+  }
+
+  // optional string invitee_name = 4;
+  if (has_invitee_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->invitee_name().data(), this->invitee_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "invitee_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      4, this->invitee_name(), output);
+  }
+
+  // optional string inviter_name = 5;
+  if (has_inviter_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->inviter_name().data(), this->inviter_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "inviter_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      5, this->inviter_name(), output);
+  }
+
+  // repeated uint32 previous_role = 6 [packed = true];
+  if (this->previous_role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(6, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_previous_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->previous_role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->previous_role(i), output);
+  }
+
+  // repeated uint32 desired_role = 7 [packed = true];
+  if (this->desired_role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(7, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_desired_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->desired_role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->desired_role(i), output);
+  }
+
+  // optional uint32 reason = 8;
+  if (has_reason()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->reason(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.GenericInvitationRequest)
+}
+
+::google::protobuf::uint8* GenericInvitationRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.GenericInvitationRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->target_id(), target);
+  }
+
+  // required fixed64 invitation_id = 3;
+  if (has_invitation_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->invitation_id(), target);
+  }
+
+  // optional string invitee_name = 4;
+  if (has_invitee_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->invitee_name().data(), this->invitee_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "invitee_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        4, this->invitee_name(), target);
+  }
+
+  // optional string inviter_name = 5;
+  if (has_inviter_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->inviter_name().data(), this->inviter_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "inviter_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        5, this->inviter_name(), target);
+  }
+
+  // repeated uint32 previous_role = 6 [packed = true];
+  if (this->previous_role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      6,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _previous_role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->previous_role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->previous_role(i), target);
+  }
+
+  // repeated uint32 desired_role = 7 [packed = true];
+  if (this->desired_role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      7,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _desired_role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->desired_role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->desired_role(i), target);
+  }
+
+  // optional uint32 reason = 8;
+  if (has_reason()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(8, this->reason(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.GenericInvitationRequest)
+  return target;
+}
+
+int GenericInvitationRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional .bgs.protocol.EntityId target_id = 2;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+    // required fixed64 invitation_id = 3;
+    if (has_invitation_id()) {
+      total_size += 1 + 8;
+    }
+
+    // optional string invitee_name = 4;
+    if (has_invitee_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->invitee_name());
+    }
+
+    // optional string inviter_name = 5;
+    if (has_inviter_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->inviter_name());
+    }
+
+    // optional uint32 reason = 8;
+    if (has_reason()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->reason());
+    }
+
+  }
+  // repeated uint32 previous_role = 6 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->previous_role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->previous_role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _previous_role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 desired_role = 7 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->desired_role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->desired_role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _desired_role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void GenericInvitationRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const GenericInvitationRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const GenericInvitationRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void GenericInvitationRequest::MergeFrom(const GenericInvitationRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  previous_role_.MergeFrom(from.previous_role_);
+  desired_role_.MergeFrom(from.desired_role_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id());
+    }
+    if (from.has_invitation_id()) {
+      set_invitation_id(from.invitation_id());
+    }
+    if (from.has_invitee_name()) {
+      set_invitee_name(from.invitee_name());
+    }
+    if (from.has_inviter_name()) {
+      set_inviter_name(from.inviter_name());
+    }
+    if (from.has_reason()) {
+      set_reason(from.reason());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void GenericInvitationRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void GenericInvitationRequest::CopyFrom(const GenericInvitationRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool GenericInvitationRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000004) != 0x00000004) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void GenericInvitationRequest::Swap(GenericInvitationRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(target_id_, other->target_id_);
+    std::swap(invitation_id_, other->invitation_id_);
+    std::swap(invitee_name_, other->invitee_name_);
+    std::swap(inviter_name_, other->inviter_name_);
+    previous_role_.Swap(&other->previous_role_);
+    desired_role_.Swap(&other->desired_role_);
+    std::swap(reason_, other->reason_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata GenericInvitationRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = GenericInvitationRequest_descriptor_;
+  metadata.reflection = GenericInvitationRequest_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/invitation_types.pb.h b/src/server/proto/Client/invitation_types.pb.h
new file mode 100644
index 00000000000..394e2ffd17f
--- /dev/null
+++ b/src/server/proto/Client/invitation_types.pb.h
@@ -0,0 +1,2801 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: invitation_types.proto
+
+#ifndef PROTOBUF_invitation_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_invitation_5ftypes_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 "entity_types.pb.h"
+#include "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto();
+void protobuf_AssignDesc_invitation_5ftypes_2eproto();
+void protobuf_ShutdownFile_invitation_5ftypes_2eproto();
+
+class Invitation;
+class InvitationSuggestion;
+class InvitationTarget;
+class InvitationParams;
+class SendInvitationRequest;
+class SendInvitationResponse;
+class UpdateInvitationRequest;
+class GenericInvitationRequest;
+
+// ===================================================================
+
+class TC_SHARED_API Invitation : public ::google::protobuf::Message {
+ public:
+  Invitation();
+  virtual ~Invitation();
+
+  Invitation(const Invitation& from);
+
+  inline Invitation& operator=(const Invitation& 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 Invitation& default_instance();
+
+  void Swap(Invitation* other);
+
+  // implements Message ----------------------------------------------
+
+  Invitation* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Invitation& from);
+  void MergeFrom(const Invitation& 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 fixed64 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 id() const;
+  inline void set_id(::google::protobuf::uint64 value);
+
+  // required .bgs.protocol.Identity inviter_identity = 2;
+  inline bool has_inviter_identity() const;
+  inline void clear_inviter_identity();
+  static const int kInviterIdentityFieldNumber = 2;
+  inline const ::bgs::protocol::Identity& inviter_identity() const;
+  inline ::bgs::protocol::Identity* mutable_inviter_identity();
+  inline ::bgs::protocol::Identity* release_inviter_identity();
+  inline void set_allocated_inviter_identity(::bgs::protocol::Identity* inviter_identity);
+
+  // required .bgs.protocol.Identity invitee_identity = 3;
+  inline bool has_invitee_identity() const;
+  inline void clear_invitee_identity();
+  static const int kInviteeIdentityFieldNumber = 3;
+  inline const ::bgs::protocol::Identity& invitee_identity() const;
+  inline ::bgs::protocol::Identity* mutable_invitee_identity();
+  inline ::bgs::protocol::Identity* release_invitee_identity();
+  inline void set_allocated_invitee_identity(::bgs::protocol::Identity* invitee_identity);
+
+  // optional string inviter_name = 4;
+  inline bool has_inviter_name() const;
+  inline void clear_inviter_name();
+  static const int kInviterNameFieldNumber = 4;
+  inline const ::std::string& inviter_name() const;
+  inline void set_inviter_name(const ::std::string& value);
+  inline void set_inviter_name(const char* value);
+  inline void set_inviter_name(const char* value, size_t size);
+  inline ::std::string* mutable_inviter_name();
+  inline ::std::string* release_inviter_name();
+  inline void set_allocated_inviter_name(::std::string* inviter_name);
+
+  // optional string invitee_name = 5;
+  inline bool has_invitee_name() const;
+  inline void clear_invitee_name();
+  static const int kInviteeNameFieldNumber = 5;
+  inline const ::std::string& invitee_name() const;
+  inline void set_invitee_name(const ::std::string& value);
+  inline void set_invitee_name(const char* value);
+  inline void set_invitee_name(const char* value, size_t size);
+  inline ::std::string* mutable_invitee_name();
+  inline ::std::string* release_invitee_name();
+  inline void set_allocated_invitee_name(::std::string* invitee_name);
+
+  // optional string invitation_message = 6;
+  inline bool has_invitation_message() const;
+  inline void clear_invitation_message();
+  static const int kInvitationMessageFieldNumber = 6;
+  inline const ::std::string& invitation_message() const;
+  inline void set_invitation_message(const ::std::string& value);
+  inline void set_invitation_message(const char* value);
+  inline void set_invitation_message(const char* value, size_t size);
+  inline ::std::string* mutable_invitation_message();
+  inline ::std::string* release_invitation_message();
+  inline void set_allocated_invitation_message(::std::string* invitation_message);
+
+  // optional uint64 creation_time = 7;
+  inline bool has_creation_time() const;
+  inline void clear_creation_time();
+  static const int kCreationTimeFieldNumber = 7;
+  inline ::google::protobuf::uint64 creation_time() const;
+  inline void set_creation_time(::google::protobuf::uint64 value);
+
+  // optional uint64 expiration_time = 8;
+  inline bool has_expiration_time() const;
+  inline void clear_expiration_time();
+  static const int kExpirationTimeFieldNumber = 8;
+  inline ::google::protobuf::uint64 expiration_time() const;
+  inline void set_expiration_time(::google::protobuf::uint64 value);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(Invitation)
+  // @@protoc_insertion_point(class_scope:bgs.protocol.Invitation)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_inviter_identity();
+  inline void clear_has_inviter_identity();
+  inline void set_has_invitee_identity();
+  inline void clear_has_invitee_identity();
+  inline void set_has_inviter_name();
+  inline void clear_has_inviter_name();
+  inline void set_has_invitee_name();
+  inline void clear_has_invitee_name();
+  inline void set_has_invitation_message();
+  inline void clear_has_invitation_message();
+  inline void set_has_creation_time();
+  inline void clear_has_creation_time();
+  inline void set_has_expiration_time();
+  inline void clear_has_expiration_time();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 id_;
+  ::bgs::protocol::Identity* inviter_identity_;
+  ::bgs::protocol::Identity* invitee_identity_;
+  ::std::string* inviter_name_;
+  ::std::string* invitee_name_;
+  ::std::string* invitation_message_;
+  ::google::protobuf::uint64 creation_time_;
+  ::google::protobuf::uint64 expiration_time_;
+  friend void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_invitation_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Invitation* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API InvitationSuggestion : public ::google::protobuf::Message {
+ public:
+  InvitationSuggestion();
+  virtual ~InvitationSuggestion();
+
+  InvitationSuggestion(const InvitationSuggestion& from);
+
+  inline InvitationSuggestion& operator=(const InvitationSuggestion& 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 InvitationSuggestion& default_instance();
+
+  void Swap(InvitationSuggestion* other);
+
+  // implements Message ----------------------------------------------
+
+  InvitationSuggestion* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const InvitationSuggestion& from);
+  void MergeFrom(const InvitationSuggestion& 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.EntityId channel_id = 1;
+  inline bool has_channel_id() const;
+  inline void clear_channel_id();
+  static const int kChannelIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& channel_id() const;
+  inline ::bgs::protocol::EntityId* mutable_channel_id();
+  inline ::bgs::protocol::EntityId* release_channel_id();
+  inline void set_allocated_channel_id(::bgs::protocol::EntityId* channel_id);
+
+  // required .bgs.protocol.EntityId suggester_id = 2;
+  inline bool has_suggester_id() const;
+  inline void clear_suggester_id();
+  static const int kSuggesterIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& suggester_id() const;
+  inline ::bgs::protocol::EntityId* mutable_suggester_id();
+  inline ::bgs::protocol::EntityId* release_suggester_id();
+  inline void set_allocated_suggester_id(::bgs::protocol::EntityId* suggester_id);
+
+  // required .bgs.protocol.EntityId suggestee_id = 3;
+  inline bool has_suggestee_id() const;
+  inline void clear_suggestee_id();
+  static const int kSuggesteeIdFieldNumber = 3;
+  inline const ::bgs::protocol::EntityId& suggestee_id() const;
+  inline ::bgs::protocol::EntityId* mutable_suggestee_id();
+  inline ::bgs::protocol::EntityId* release_suggestee_id();
+  inline void set_allocated_suggestee_id(::bgs::protocol::EntityId* suggestee_id);
+
+  // optional string suggester_name = 4;
+  inline bool has_suggester_name() const;
+  inline void clear_suggester_name();
+  static const int kSuggesterNameFieldNumber = 4;
+  inline const ::std::string& suggester_name() const;
+  inline void set_suggester_name(const ::std::string& value);
+  inline void set_suggester_name(const char* value);
+  inline void set_suggester_name(const char* value, size_t size);
+  inline ::std::string* mutable_suggester_name();
+  inline ::std::string* release_suggester_name();
+  inline void set_allocated_suggester_name(::std::string* suggester_name);
+
+  // optional string suggestee_name = 5;
+  inline bool has_suggestee_name() const;
+  inline void clear_suggestee_name();
+  static const int kSuggesteeNameFieldNumber = 5;
+  inline const ::std::string& suggestee_name() const;
+  inline void set_suggestee_name(const ::std::string& value);
+  inline void set_suggestee_name(const char* value);
+  inline void set_suggestee_name(const char* value, size_t size);
+  inline ::std::string* mutable_suggestee_name();
+  inline ::std::string* release_suggestee_name();
+  inline void set_allocated_suggestee_name(::std::string* suggestee_name);
+
+  // optional .bgs.protocol.EntityId suggester_account_id = 6;
+  inline bool has_suggester_account_id() const;
+  inline void clear_suggester_account_id();
+  static const int kSuggesterAccountIdFieldNumber = 6;
+  inline const ::bgs::protocol::EntityId& suggester_account_id() const;
+  inline ::bgs::protocol::EntityId* mutable_suggester_account_id();
+  inline ::bgs::protocol::EntityId* release_suggester_account_id();
+  inline void set_allocated_suggester_account_id(::bgs::protocol::EntityId* suggester_account_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.InvitationSuggestion)
+ private:
+  inline void set_has_channel_id();
+  inline void clear_has_channel_id();
+  inline void set_has_suggester_id();
+  inline void clear_has_suggester_id();
+  inline void set_has_suggestee_id();
+  inline void clear_has_suggestee_id();
+  inline void set_has_suggester_name();
+  inline void clear_has_suggester_name();
+  inline void set_has_suggestee_name();
+  inline void clear_has_suggestee_name();
+  inline void set_has_suggester_account_id();
+  inline void clear_has_suggester_account_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* channel_id_;
+  ::bgs::protocol::EntityId* suggester_id_;
+  ::bgs::protocol::EntityId* suggestee_id_;
+  ::std::string* suggester_name_;
+  ::std::string* suggestee_name_;
+  ::bgs::protocol::EntityId* suggester_account_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_invitation_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static InvitationSuggestion* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API InvitationTarget : public ::google::protobuf::Message {
+ public:
+  InvitationTarget();
+  virtual ~InvitationTarget();
+
+  InvitationTarget(const InvitationTarget& from);
+
+  inline InvitationTarget& operator=(const InvitationTarget& 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 InvitationTarget& default_instance();
+
+  void Swap(InvitationTarget* other);
+
+  // implements Message ----------------------------------------------
+
+  InvitationTarget* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const InvitationTarget& from);
+  void MergeFrom(const InvitationTarget& 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.Identity identity = 1;
+  inline bool has_identity() const;
+  inline void clear_identity();
+  static const int kIdentityFieldNumber = 1;
+  inline const ::bgs::protocol::Identity& identity() const;
+  inline ::bgs::protocol::Identity* mutable_identity();
+  inline ::bgs::protocol::Identity* release_identity();
+  inline void set_allocated_identity(::bgs::protocol::Identity* identity);
+
+  // optional string email = 2;
+  inline bool has_email() const;
+  inline void clear_email();
+  static const int kEmailFieldNumber = 2;
+  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 battle_tag = 3;
+  inline bool has_battle_tag() const;
+  inline void clear_battle_tag();
+  static const int kBattleTagFieldNumber = 3;
+  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);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(InvitationTarget)
+  // @@protoc_insertion_point(class_scope:bgs.protocol.InvitationTarget)
+ private:
+  inline void set_has_identity();
+  inline void clear_has_identity();
+  inline void set_has_email();
+  inline void clear_has_email();
+  inline void set_has_battle_tag();
+  inline void clear_has_battle_tag();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::Identity* identity_;
+  ::std::string* email_;
+  ::std::string* battle_tag_;
+  friend void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_invitation_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static InvitationTarget* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API InvitationParams : public ::google::protobuf::Message {
+ public:
+  InvitationParams();
+  virtual ~InvitationParams();
+
+  InvitationParams(const InvitationParams& from);
+
+  inline InvitationParams& operator=(const InvitationParams& 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 InvitationParams& default_instance();
+
+  void Swap(InvitationParams* other);
+
+  // implements Message ----------------------------------------------
+
+  InvitationParams* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const InvitationParams& from);
+  void MergeFrom(const InvitationParams& 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 invitation_message = 1;
+  inline bool has_invitation_message() const;
+  inline void clear_invitation_message();
+  static const int kInvitationMessageFieldNumber = 1;
+  inline const ::std::string& invitation_message() const;
+  inline void set_invitation_message(const ::std::string& value);
+  inline void set_invitation_message(const char* value);
+  inline void set_invitation_message(const char* value, size_t size);
+  inline ::std::string* mutable_invitation_message();
+  inline ::std::string* release_invitation_message();
+  inline void set_allocated_invitation_message(::std::string* invitation_message);
+
+  // optional uint64 expiration_time = 2 [default = 0];
+  inline bool has_expiration_time() const;
+  inline void clear_expiration_time();
+  static const int kExpirationTimeFieldNumber = 2;
+  inline ::google::protobuf::uint64 expiration_time() const;
+  inline void set_expiration_time(::google::protobuf::uint64 value);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(InvitationParams)
+  // @@protoc_insertion_point(class_scope:bgs.protocol.InvitationParams)
+ private:
+  inline void set_has_invitation_message();
+  inline void clear_has_invitation_message();
+  inline void set_has_expiration_time();
+  inline void clear_has_expiration_time();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* invitation_message_;
+  ::google::protobuf::uint64 expiration_time_;
+  friend void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_invitation_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static InvitationParams* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API SendInvitationRequest : public ::google::protobuf::Message {
+ public:
+  SendInvitationRequest();
+  virtual ~SendInvitationRequest();
+
+  SendInvitationRequest(const SendInvitationRequest& from);
+
+  inline SendInvitationRequest& operator=(const SendInvitationRequest& 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 SendInvitationRequest& default_instance();
+
+  void Swap(SendInvitationRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SendInvitationRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SendInvitationRequest& from);
+  void MergeFrom(const SendInvitationRequest& 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.Identity agent_identity = 1;
+  inline bool has_agent_identity() const;
+  inline void clear_agent_identity();
+  static const int kAgentIdentityFieldNumber = 1;
+  inline const ::bgs::protocol::Identity& agent_identity() const;
+  inline ::bgs::protocol::Identity* mutable_agent_identity();
+  inline ::bgs::protocol::Identity* release_agent_identity();
+  inline void set_allocated_agent_identity(::bgs::protocol::Identity* agent_identity);
+
+  // required .bgs.protocol.EntityId target_id = 2 [deprecated = true];
+  inline bool has_target_id() const PROTOBUF_DEPRECATED;
+  inline void clear_target_id() PROTOBUF_DEPRECATED;
+  static const int kTargetIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& target_id() const PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::EntityId* mutable_target_id() PROTOBUF_DEPRECATED;
+  inline ::bgs::protocol::EntityId* release_target_id() PROTOBUF_DEPRECATED;
+  inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id) PROTOBUF_DEPRECATED;
+
+  // required .bgs.protocol.InvitationParams params = 3;
+  inline bool has_params() const;
+  inline void clear_params();
+  static const int kParamsFieldNumber = 3;
+  inline const ::bgs::protocol::InvitationParams& params() const;
+  inline ::bgs::protocol::InvitationParams* mutable_params();
+  inline ::bgs::protocol::InvitationParams* release_params();
+  inline void set_allocated_params(::bgs::protocol::InvitationParams* params);
+
+  // optional .bgs.protocol.AccountInfo agent_info = 4;
+  inline bool has_agent_info() const;
+  inline void clear_agent_info();
+  static const int kAgentInfoFieldNumber = 4;
+  inline const ::bgs::protocol::AccountInfo& agent_info() const;
+  inline ::bgs::protocol::AccountInfo* mutable_agent_info();
+  inline ::bgs::protocol::AccountInfo* release_agent_info();
+  inline void set_allocated_agent_info(::bgs::protocol::AccountInfo* agent_info);
+
+  // optional .bgs.protocol.InvitationTarget target = 5;
+  inline bool has_target() const;
+  inline void clear_target();
+  static const int kTargetFieldNumber = 5;
+  inline const ::bgs::protocol::InvitationTarget& target() const;
+  inline ::bgs::protocol::InvitationTarget* mutable_target();
+  inline ::bgs::protocol::InvitationTarget* release_target();
+  inline void set_allocated_target(::bgs::protocol::InvitationTarget* target);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.SendInvitationRequest)
+ private:
+  inline void set_has_agent_identity();
+  inline void clear_has_agent_identity();
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+  inline void set_has_params();
+  inline void clear_has_params();
+  inline void set_has_agent_info();
+  inline void clear_has_agent_info();
+  inline void set_has_target();
+  inline void clear_has_target();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::Identity* agent_identity_;
+  ::bgs::protocol::EntityId* target_id_;
+  ::bgs::protocol::InvitationParams* params_;
+  ::bgs::protocol::AccountInfo* agent_info_;
+  ::bgs::protocol::InvitationTarget* target_;
+  friend void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_invitation_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static SendInvitationRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API SendInvitationResponse : public ::google::protobuf::Message {
+ public:
+  SendInvitationResponse();
+  virtual ~SendInvitationResponse();
+
+  SendInvitationResponse(const SendInvitationResponse& from);
+
+  inline SendInvitationResponse& operator=(const SendInvitationResponse& 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 SendInvitationResponse& default_instance();
+
+  void Swap(SendInvitationResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  SendInvitationResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SendInvitationResponse& from);
+  void MergeFrom(const SendInvitationResponse& 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.Invitation invitation = 2;
+  inline bool has_invitation() const;
+  inline void clear_invitation();
+  static const int kInvitationFieldNumber = 2;
+  inline const ::bgs::protocol::Invitation& invitation() const;
+  inline ::bgs::protocol::Invitation* mutable_invitation();
+  inline ::bgs::protocol::Invitation* release_invitation();
+  inline void set_allocated_invitation(::bgs::protocol::Invitation* invitation);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.SendInvitationResponse)
+ private:
+  inline void set_has_invitation();
+  inline void clear_has_invitation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::Invitation* invitation_;
+  friend void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_invitation_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static SendInvitationResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API UpdateInvitationRequest : public ::google::protobuf::Message {
+ public:
+  UpdateInvitationRequest();
+  virtual ~UpdateInvitationRequest();
+
+  UpdateInvitationRequest(const UpdateInvitationRequest& from);
+
+  inline UpdateInvitationRequest& operator=(const UpdateInvitationRequest& 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 UpdateInvitationRequest& default_instance();
+
+  void Swap(UpdateInvitationRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UpdateInvitationRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UpdateInvitationRequest& from);
+  void MergeFrom(const UpdateInvitationRequest& 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.Identity agent_identity = 1;
+  inline bool has_agent_identity() const;
+  inline void clear_agent_identity();
+  static const int kAgentIdentityFieldNumber = 1;
+  inline const ::bgs::protocol::Identity& agent_identity() const;
+  inline ::bgs::protocol::Identity* mutable_agent_identity();
+  inline ::bgs::protocol::Identity* release_agent_identity();
+  inline void set_allocated_agent_identity(::bgs::protocol::Identity* agent_identity);
+
+  // required fixed64 invitation_id = 2;
+  inline bool has_invitation_id() const;
+  inline void clear_invitation_id();
+  static const int kInvitationIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 invitation_id() const;
+  inline void set_invitation_id(::google::protobuf::uint64 value);
+
+  // required .bgs.protocol.InvitationParams params = 3;
+  inline bool has_params() const;
+  inline void clear_params();
+  static const int kParamsFieldNumber = 3;
+  inline const ::bgs::protocol::InvitationParams& params() const;
+  inline ::bgs::protocol::InvitationParams* mutable_params();
+  inline ::bgs::protocol::InvitationParams* release_params();
+  inline void set_allocated_params(::bgs::protocol::InvitationParams* params);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.UpdateInvitationRequest)
+ private:
+  inline void set_has_agent_identity();
+  inline void clear_has_agent_identity();
+  inline void set_has_invitation_id();
+  inline void clear_has_invitation_id();
+  inline void set_has_params();
+  inline void clear_has_params();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::Identity* agent_identity_;
+  ::google::protobuf::uint64 invitation_id_;
+  ::bgs::protocol::InvitationParams* params_;
+  friend void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_invitation_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static UpdateInvitationRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API GenericInvitationRequest : public ::google::protobuf::Message {
+ public:
+  GenericInvitationRequest();
+  virtual ~GenericInvitationRequest();
+
+  GenericInvitationRequest(const GenericInvitationRequest& from);
+
+  inline GenericInvitationRequest& operator=(const GenericInvitationRequest& 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 GenericInvitationRequest& default_instance();
+
+  void Swap(GenericInvitationRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  GenericInvitationRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const GenericInvitationRequest& from);
+  void MergeFrom(const GenericInvitationRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // optional .bgs.protocol.EntityId target_id = 2;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& target_id() const;
+  inline ::bgs::protocol::EntityId* mutable_target_id();
+  inline ::bgs::protocol::EntityId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id);
+
+  // required fixed64 invitation_id = 3;
+  inline bool has_invitation_id() const;
+  inline void clear_invitation_id();
+  static const int kInvitationIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 invitation_id() const;
+  inline void set_invitation_id(::google::protobuf::uint64 value);
+
+  // optional string invitee_name = 4;
+  inline bool has_invitee_name() const;
+  inline void clear_invitee_name();
+  static const int kInviteeNameFieldNumber = 4;
+  inline const ::std::string& invitee_name() const;
+  inline void set_invitee_name(const ::std::string& value);
+  inline void set_invitee_name(const char* value);
+  inline void set_invitee_name(const char* value, size_t size);
+  inline ::std::string* mutable_invitee_name();
+  inline ::std::string* release_invitee_name();
+  inline void set_allocated_invitee_name(::std::string* invitee_name);
+
+  // optional string inviter_name = 5;
+  inline bool has_inviter_name() const;
+  inline void clear_inviter_name();
+  static const int kInviterNameFieldNumber = 5;
+  inline const ::std::string& inviter_name() const;
+  inline void set_inviter_name(const ::std::string& value);
+  inline void set_inviter_name(const char* value);
+  inline void set_inviter_name(const char* value, size_t size);
+  inline ::std::string* mutable_inviter_name();
+  inline ::std::string* release_inviter_name();
+  inline void set_allocated_inviter_name(::std::string* inviter_name);
+
+  // repeated uint32 previous_role = 6 [packed = true];
+  inline int previous_role_size() const;
+  inline void clear_previous_role();
+  static const int kPreviousRoleFieldNumber = 6;
+  inline ::google::protobuf::uint32 previous_role(int index) const;
+  inline void set_previous_role(int index, ::google::protobuf::uint32 value);
+  inline void add_previous_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      previous_role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_previous_role();
+
+  // repeated uint32 desired_role = 7 [packed = true];
+  inline int desired_role_size() const;
+  inline void clear_desired_role();
+  static const int kDesiredRoleFieldNumber = 7;
+  inline ::google::protobuf::uint32 desired_role(int index) const;
+  inline void set_desired_role(int index, ::google::protobuf::uint32 value);
+  inline void add_desired_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      desired_role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_desired_role();
+
+  // optional uint32 reason = 8;
+  inline bool has_reason() const;
+  inline void clear_reason();
+  static const int kReasonFieldNumber = 8;
+  inline ::google::protobuf::uint32 reason() const;
+  inline void set_reason(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.GenericInvitationRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+  inline void set_has_invitation_id();
+  inline void clear_has_invitation_id();
+  inline void set_has_invitee_name();
+  inline void clear_has_invitee_name();
+  inline void set_has_inviter_name();
+  inline void clear_has_inviter_name();
+  inline void set_has_reason();
+  inline void clear_has_reason();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::EntityId* target_id_;
+  ::google::protobuf::uint64 invitation_id_;
+  ::std::string* invitee_name_;
+  ::std::string* inviter_name_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > previous_role_;
+  mutable int _previous_role_cached_byte_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > desired_role_;
+  mutable int _desired_role_cached_byte_size_;
+  ::google::protobuf::uint32 reason_;
+  friend void TC_SHARED_API protobuf_AddDesc_invitation_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_invitation_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_invitation_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static GenericInvitationRequest* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// Invitation
+
+// required fixed64 id = 1;
+inline bool Invitation::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Invitation::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Invitation::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Invitation::clear_id() {
+  id_ = GOOGLE_ULONGLONG(0);
+  clear_has_id();
+}
+inline ::google::protobuf::uint64 Invitation::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Invitation.id)
+  return id_;
+}
+inline void Invitation::set_id(::google::protobuf::uint64 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Invitation.id)
+}
+
+// required .bgs.protocol.Identity inviter_identity = 2;
+inline bool Invitation::has_inviter_identity() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Invitation::set_has_inviter_identity() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Invitation::clear_has_inviter_identity() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Invitation::clear_inviter_identity() {
+  if (inviter_identity_ != NULL) inviter_identity_->::bgs::protocol::Identity::Clear();
+  clear_has_inviter_identity();
+}
+inline const ::bgs::protocol::Identity& Invitation::inviter_identity() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Invitation.inviter_identity)
+  return inviter_identity_ != NULL ? *inviter_identity_ : *default_instance_->inviter_identity_;
+}
+inline ::bgs::protocol::Identity* Invitation::mutable_inviter_identity() {
+  set_has_inviter_identity();
+  if (inviter_identity_ == NULL) inviter_identity_ = new ::bgs::protocol::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Invitation.inviter_identity)
+  return inviter_identity_;
+}
+inline ::bgs::protocol::Identity* Invitation::release_inviter_identity() {
+  clear_has_inviter_identity();
+  ::bgs::protocol::Identity* temp = inviter_identity_;
+  inviter_identity_ = NULL;
+  return temp;
+}
+inline void Invitation::set_allocated_inviter_identity(::bgs::protocol::Identity* inviter_identity) {
+  delete inviter_identity_;
+  inviter_identity_ = inviter_identity;
+  if (inviter_identity) {
+    set_has_inviter_identity();
+  } else {
+    clear_has_inviter_identity();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Invitation.inviter_identity)
+}
+
+// required .bgs.protocol.Identity invitee_identity = 3;
+inline bool Invitation::has_invitee_identity() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Invitation::set_has_invitee_identity() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Invitation::clear_has_invitee_identity() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Invitation::clear_invitee_identity() {
+  if (invitee_identity_ != NULL) invitee_identity_->::bgs::protocol::Identity::Clear();
+  clear_has_invitee_identity();
+}
+inline const ::bgs::protocol::Identity& Invitation::invitee_identity() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Invitation.invitee_identity)
+  return invitee_identity_ != NULL ? *invitee_identity_ : *default_instance_->invitee_identity_;
+}
+inline ::bgs::protocol::Identity* Invitation::mutable_invitee_identity() {
+  set_has_invitee_identity();
+  if (invitee_identity_ == NULL) invitee_identity_ = new ::bgs::protocol::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Invitation.invitee_identity)
+  return invitee_identity_;
+}
+inline ::bgs::protocol::Identity* Invitation::release_invitee_identity() {
+  clear_has_invitee_identity();
+  ::bgs::protocol::Identity* temp = invitee_identity_;
+  invitee_identity_ = NULL;
+  return temp;
+}
+inline void Invitation::set_allocated_invitee_identity(::bgs::protocol::Identity* invitee_identity) {
+  delete invitee_identity_;
+  invitee_identity_ = invitee_identity;
+  if (invitee_identity) {
+    set_has_invitee_identity();
+  } else {
+    clear_has_invitee_identity();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Invitation.invitee_identity)
+}
+
+// optional string inviter_name = 4;
+inline bool Invitation::has_inviter_name() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Invitation::set_has_inviter_name() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Invitation::clear_has_inviter_name() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Invitation::clear_inviter_name() {
+  if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_name_->clear();
+  }
+  clear_has_inviter_name();
+}
+inline const ::std::string& Invitation::inviter_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Invitation.inviter_name)
+  return *inviter_name_;
+}
+inline void Invitation::set_inviter_name(const ::std::string& value) {
+  set_has_inviter_name();
+  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_name_ = new ::std::string;
+  }
+  inviter_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.Invitation.inviter_name)
+}
+inline void Invitation::set_inviter_name(const char* value) {
+  set_has_inviter_name();
+  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_name_ = new ::std::string;
+  }
+  inviter_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.Invitation.inviter_name)
+}
+inline void Invitation::set_inviter_name(const char* value, size_t size) {
+  set_has_inviter_name();
+  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_name_ = new ::std::string;
+  }
+  inviter_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Invitation.inviter_name)
+}
+inline ::std::string* Invitation::mutable_inviter_name() {
+  set_has_inviter_name();
+  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Invitation.inviter_name)
+  return inviter_name_;
+}
+inline ::std::string* Invitation::release_inviter_name() {
+  clear_has_inviter_name();
+  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = inviter_name_;
+    inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Invitation::set_allocated_inviter_name(::std::string* inviter_name) {
+  if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete inviter_name_;
+  }
+  if (inviter_name) {
+    set_has_inviter_name();
+    inviter_name_ = inviter_name;
+  } else {
+    clear_has_inviter_name();
+    inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Invitation.inviter_name)
+}
+
+// optional string invitee_name = 5;
+inline bool Invitation::has_invitee_name() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void Invitation::set_has_invitee_name() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void Invitation::clear_has_invitee_name() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void Invitation::clear_invitee_name() {
+  if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_name_->clear();
+  }
+  clear_has_invitee_name();
+}
+inline const ::std::string& Invitation::invitee_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Invitation.invitee_name)
+  return *invitee_name_;
+}
+inline void Invitation::set_invitee_name(const ::std::string& value) {
+  set_has_invitee_name();
+  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_name_ = new ::std::string;
+  }
+  invitee_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.Invitation.invitee_name)
+}
+inline void Invitation::set_invitee_name(const char* value) {
+  set_has_invitee_name();
+  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_name_ = new ::std::string;
+  }
+  invitee_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.Invitation.invitee_name)
+}
+inline void Invitation::set_invitee_name(const char* value, size_t size) {
+  set_has_invitee_name();
+  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_name_ = new ::std::string;
+  }
+  invitee_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Invitation.invitee_name)
+}
+inline ::std::string* Invitation::mutable_invitee_name() {
+  set_has_invitee_name();
+  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Invitation.invitee_name)
+  return invitee_name_;
+}
+inline ::std::string* Invitation::release_invitee_name() {
+  clear_has_invitee_name();
+  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = invitee_name_;
+    invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Invitation::set_allocated_invitee_name(::std::string* invitee_name) {
+  if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete invitee_name_;
+  }
+  if (invitee_name) {
+    set_has_invitee_name();
+    invitee_name_ = invitee_name;
+  } else {
+    clear_has_invitee_name();
+    invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Invitation.invitee_name)
+}
+
+// optional string invitation_message = 6;
+inline bool Invitation::has_invitation_message() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void Invitation::set_has_invitation_message() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void Invitation::clear_has_invitation_message() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void Invitation::clear_invitation_message() {
+  if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitation_message_->clear();
+  }
+  clear_has_invitation_message();
+}
+inline const ::std::string& Invitation::invitation_message() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Invitation.invitation_message)
+  return *invitation_message_;
+}
+inline void Invitation::set_invitation_message(const ::std::string& value) {
+  set_has_invitation_message();
+  if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitation_message_ = new ::std::string;
+  }
+  invitation_message_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.Invitation.invitation_message)
+}
+inline void Invitation::set_invitation_message(const char* value) {
+  set_has_invitation_message();
+  if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitation_message_ = new ::std::string;
+  }
+  invitation_message_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.Invitation.invitation_message)
+}
+inline void Invitation::set_invitation_message(const char* value, size_t size) {
+  set_has_invitation_message();
+  if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitation_message_ = new ::std::string;
+  }
+  invitation_message_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Invitation.invitation_message)
+}
+inline ::std::string* Invitation::mutable_invitation_message() {
+  set_has_invitation_message();
+  if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitation_message_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Invitation.invitation_message)
+  return invitation_message_;
+}
+inline ::std::string* Invitation::release_invitation_message() {
+  clear_has_invitation_message();
+  if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = invitation_message_;
+    invitation_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Invitation::set_allocated_invitation_message(::std::string* invitation_message) {
+  if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete invitation_message_;
+  }
+  if (invitation_message) {
+    set_has_invitation_message();
+    invitation_message_ = invitation_message;
+  } else {
+    clear_has_invitation_message();
+    invitation_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Invitation.invitation_message)
+}
+
+// optional uint64 creation_time = 7;
+inline bool Invitation::has_creation_time() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void Invitation::set_has_creation_time() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void Invitation::clear_has_creation_time() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void Invitation::clear_creation_time() {
+  creation_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_creation_time();
+}
+inline ::google::protobuf::uint64 Invitation::creation_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Invitation.creation_time)
+  return creation_time_;
+}
+inline void Invitation::set_creation_time(::google::protobuf::uint64 value) {
+  set_has_creation_time();
+  creation_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Invitation.creation_time)
+}
+
+// optional uint64 expiration_time = 8;
+inline bool Invitation::has_expiration_time() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void Invitation::set_has_expiration_time() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void Invitation::clear_has_expiration_time() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void Invitation::clear_expiration_time() {
+  expiration_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_expiration_time();
+}
+inline ::google::protobuf::uint64 Invitation::expiration_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Invitation.expiration_time)
+  return expiration_time_;
+}
+inline void Invitation::set_expiration_time(::google::protobuf::uint64 value) {
+  set_has_expiration_time();
+  expiration_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Invitation.expiration_time)
+}
+
+// -------------------------------------------------------------------
+
+// InvitationSuggestion
+
+// optional .bgs.protocol.EntityId channel_id = 1;
+inline bool InvitationSuggestion::has_channel_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void InvitationSuggestion::set_has_channel_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void InvitationSuggestion::clear_has_channel_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void InvitationSuggestion::clear_channel_id() {
+  if (channel_id_ != NULL) channel_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_channel_id();
+}
+inline const ::bgs::protocol::EntityId& InvitationSuggestion::channel_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.channel_id)
+  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
+}
+inline ::bgs::protocol::EntityId* InvitationSuggestion::mutable_channel_id() {
+  set_has_channel_id();
+  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.channel_id)
+  return channel_id_;
+}
+inline ::bgs::protocol::EntityId* InvitationSuggestion::release_channel_id() {
+  clear_has_channel_id();
+  ::bgs::protocol::EntityId* temp = channel_id_;
+  channel_id_ = NULL;
+  return temp;
+}
+inline void InvitationSuggestion::set_allocated_channel_id(::bgs::protocol::EntityId* channel_id) {
+  delete channel_id_;
+  channel_id_ = channel_id;
+  if (channel_id) {
+    set_has_channel_id();
+  } else {
+    clear_has_channel_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.channel_id)
+}
+
+// required .bgs.protocol.EntityId suggester_id = 2;
+inline bool InvitationSuggestion::has_suggester_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void InvitationSuggestion::set_has_suggester_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void InvitationSuggestion::clear_has_suggester_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void InvitationSuggestion::clear_suggester_id() {
+  if (suggester_id_ != NULL) suggester_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_suggester_id();
+}
+inline const ::bgs::protocol::EntityId& InvitationSuggestion::suggester_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.suggester_id)
+  return suggester_id_ != NULL ? *suggester_id_ : *default_instance_->suggester_id_;
+}
+inline ::bgs::protocol::EntityId* InvitationSuggestion::mutable_suggester_id() {
+  set_has_suggester_id();
+  if (suggester_id_ == NULL) suggester_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.suggester_id)
+  return suggester_id_;
+}
+inline ::bgs::protocol::EntityId* InvitationSuggestion::release_suggester_id() {
+  clear_has_suggester_id();
+  ::bgs::protocol::EntityId* temp = suggester_id_;
+  suggester_id_ = NULL;
+  return temp;
+}
+inline void InvitationSuggestion::set_allocated_suggester_id(::bgs::protocol::EntityId* suggester_id) {
+  delete suggester_id_;
+  suggester_id_ = suggester_id;
+  if (suggester_id) {
+    set_has_suggester_id();
+  } else {
+    clear_has_suggester_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.suggester_id)
+}
+
+// required .bgs.protocol.EntityId suggestee_id = 3;
+inline bool InvitationSuggestion::has_suggestee_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void InvitationSuggestion::set_has_suggestee_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void InvitationSuggestion::clear_has_suggestee_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void InvitationSuggestion::clear_suggestee_id() {
+  if (suggestee_id_ != NULL) suggestee_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_suggestee_id();
+}
+inline const ::bgs::protocol::EntityId& InvitationSuggestion::suggestee_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.suggestee_id)
+  return suggestee_id_ != NULL ? *suggestee_id_ : *default_instance_->suggestee_id_;
+}
+inline ::bgs::protocol::EntityId* InvitationSuggestion::mutable_suggestee_id() {
+  set_has_suggestee_id();
+  if (suggestee_id_ == NULL) suggestee_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.suggestee_id)
+  return suggestee_id_;
+}
+inline ::bgs::protocol::EntityId* InvitationSuggestion::release_suggestee_id() {
+  clear_has_suggestee_id();
+  ::bgs::protocol::EntityId* temp = suggestee_id_;
+  suggestee_id_ = NULL;
+  return temp;
+}
+inline void InvitationSuggestion::set_allocated_suggestee_id(::bgs::protocol::EntityId* suggestee_id) {
+  delete suggestee_id_;
+  suggestee_id_ = suggestee_id;
+  if (suggestee_id) {
+    set_has_suggestee_id();
+  } else {
+    clear_has_suggestee_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.suggestee_id)
+}
+
+// optional string suggester_name = 4;
+inline bool InvitationSuggestion::has_suggester_name() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void InvitationSuggestion::set_has_suggester_name() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void InvitationSuggestion::clear_has_suggester_name() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void InvitationSuggestion::clear_suggester_name() {
+  if (suggester_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    suggester_name_->clear();
+  }
+  clear_has_suggester_name();
+}
+inline const ::std::string& InvitationSuggestion::suggester_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.suggester_name)
+  return *suggester_name_;
+}
+inline void InvitationSuggestion::set_suggester_name(const ::std::string& value) {
+  set_has_suggester_name();
+  if (suggester_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    suggester_name_ = new ::std::string;
+  }
+  suggester_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.InvitationSuggestion.suggester_name)
+}
+inline void InvitationSuggestion::set_suggester_name(const char* value) {
+  set_has_suggester_name();
+  if (suggester_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    suggester_name_ = new ::std::string;
+  }
+  suggester_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.InvitationSuggestion.suggester_name)
+}
+inline void InvitationSuggestion::set_suggester_name(const char* value, size_t size) {
+  set_has_suggester_name();
+  if (suggester_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    suggester_name_ = new ::std::string;
+  }
+  suggester_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.InvitationSuggestion.suggester_name)
+}
+inline ::std::string* InvitationSuggestion::mutable_suggester_name() {
+  set_has_suggester_name();
+  if (suggester_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    suggester_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.suggester_name)
+  return suggester_name_;
+}
+inline ::std::string* InvitationSuggestion::release_suggester_name() {
+  clear_has_suggester_name();
+  if (suggester_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = suggester_name_;
+    suggester_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void InvitationSuggestion::set_allocated_suggester_name(::std::string* suggester_name) {
+  if (suggester_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete suggester_name_;
+  }
+  if (suggester_name) {
+    set_has_suggester_name();
+    suggester_name_ = suggester_name;
+  } else {
+    clear_has_suggester_name();
+    suggester_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.suggester_name)
+}
+
+// optional string suggestee_name = 5;
+inline bool InvitationSuggestion::has_suggestee_name() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void InvitationSuggestion::set_has_suggestee_name() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void InvitationSuggestion::clear_has_suggestee_name() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void InvitationSuggestion::clear_suggestee_name() {
+  if (suggestee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    suggestee_name_->clear();
+  }
+  clear_has_suggestee_name();
+}
+inline const ::std::string& InvitationSuggestion::suggestee_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.suggestee_name)
+  return *suggestee_name_;
+}
+inline void InvitationSuggestion::set_suggestee_name(const ::std::string& value) {
+  set_has_suggestee_name();
+  if (suggestee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    suggestee_name_ = new ::std::string;
+  }
+  suggestee_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.InvitationSuggestion.suggestee_name)
+}
+inline void InvitationSuggestion::set_suggestee_name(const char* value) {
+  set_has_suggestee_name();
+  if (suggestee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    suggestee_name_ = new ::std::string;
+  }
+  suggestee_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.InvitationSuggestion.suggestee_name)
+}
+inline void InvitationSuggestion::set_suggestee_name(const char* value, size_t size) {
+  set_has_suggestee_name();
+  if (suggestee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    suggestee_name_ = new ::std::string;
+  }
+  suggestee_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.InvitationSuggestion.suggestee_name)
+}
+inline ::std::string* InvitationSuggestion::mutable_suggestee_name() {
+  set_has_suggestee_name();
+  if (suggestee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    suggestee_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.suggestee_name)
+  return suggestee_name_;
+}
+inline ::std::string* InvitationSuggestion::release_suggestee_name() {
+  clear_has_suggestee_name();
+  if (suggestee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = suggestee_name_;
+    suggestee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void InvitationSuggestion::set_allocated_suggestee_name(::std::string* suggestee_name) {
+  if (suggestee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete suggestee_name_;
+  }
+  if (suggestee_name) {
+    set_has_suggestee_name();
+    suggestee_name_ = suggestee_name;
+  } else {
+    clear_has_suggestee_name();
+    suggestee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.suggestee_name)
+}
+
+// optional .bgs.protocol.EntityId suggester_account_id = 6;
+inline bool InvitationSuggestion::has_suggester_account_id() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void InvitationSuggestion::set_has_suggester_account_id() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void InvitationSuggestion::clear_has_suggester_account_id() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void InvitationSuggestion::clear_suggester_account_id() {
+  if (suggester_account_id_ != NULL) suggester_account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_suggester_account_id();
+}
+inline const ::bgs::protocol::EntityId& InvitationSuggestion::suggester_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationSuggestion.suggester_account_id)
+  return suggester_account_id_ != NULL ? *suggester_account_id_ : *default_instance_->suggester_account_id_;
+}
+inline ::bgs::protocol::EntityId* InvitationSuggestion::mutable_suggester_account_id() {
+  set_has_suggester_account_id();
+  if (suggester_account_id_ == NULL) suggester_account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationSuggestion.suggester_account_id)
+  return suggester_account_id_;
+}
+inline ::bgs::protocol::EntityId* InvitationSuggestion::release_suggester_account_id() {
+  clear_has_suggester_account_id();
+  ::bgs::protocol::EntityId* temp = suggester_account_id_;
+  suggester_account_id_ = NULL;
+  return temp;
+}
+inline void InvitationSuggestion::set_allocated_suggester_account_id(::bgs::protocol::EntityId* suggester_account_id) {
+  delete suggester_account_id_;
+  suggester_account_id_ = suggester_account_id;
+  if (suggester_account_id) {
+    set_has_suggester_account_id();
+  } else {
+    clear_has_suggester_account_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationSuggestion.suggester_account_id)
+}
+
+// -------------------------------------------------------------------
+
+// InvitationTarget
+
+// optional .bgs.protocol.Identity identity = 1;
+inline bool InvitationTarget::has_identity() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void InvitationTarget::set_has_identity() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void InvitationTarget::clear_has_identity() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void InvitationTarget::clear_identity() {
+  if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear();
+  clear_has_identity();
+}
+inline const ::bgs::protocol::Identity& InvitationTarget::identity() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationTarget.identity)
+  return identity_ != NULL ? *identity_ : *default_instance_->identity_;
+}
+inline ::bgs::protocol::Identity* InvitationTarget::mutable_identity() {
+  set_has_identity();
+  if (identity_ == NULL) identity_ = new ::bgs::protocol::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationTarget.identity)
+  return identity_;
+}
+inline ::bgs::protocol::Identity* InvitationTarget::release_identity() {
+  clear_has_identity();
+  ::bgs::protocol::Identity* temp = identity_;
+  identity_ = NULL;
+  return temp;
+}
+inline void InvitationTarget::set_allocated_identity(::bgs::protocol::Identity* identity) {
+  delete identity_;
+  identity_ = identity;
+  if (identity) {
+    set_has_identity();
+  } else {
+    clear_has_identity();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationTarget.identity)
+}
+
+// optional string email = 2;
+inline bool InvitationTarget::has_email() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void InvitationTarget::set_has_email() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void InvitationTarget::clear_has_email() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void InvitationTarget::clear_email() {
+  if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    email_->clear();
+  }
+  clear_has_email();
+}
+inline const ::std::string& InvitationTarget::email() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationTarget.email)
+  return *email_;
+}
+inline void InvitationTarget::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.InvitationTarget.email)
+}
+inline void InvitationTarget::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.InvitationTarget.email)
+}
+inline void InvitationTarget::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.InvitationTarget.email)
+}
+inline ::std::string* InvitationTarget::mutable_email() {
+  set_has_email();
+  if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    email_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationTarget.email)
+  return email_;
+}
+inline ::std::string* InvitationTarget::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 InvitationTarget::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.InvitationTarget.email)
+}
+
+// optional string battle_tag = 3;
+inline bool InvitationTarget::has_battle_tag() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void InvitationTarget::set_has_battle_tag() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void InvitationTarget::clear_has_battle_tag() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void InvitationTarget::clear_battle_tag() {
+  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    battle_tag_->clear();
+  }
+  clear_has_battle_tag();
+}
+inline const ::std::string& InvitationTarget::battle_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationTarget.battle_tag)
+  return *battle_tag_;
+}
+inline void InvitationTarget::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.InvitationTarget.battle_tag)
+}
+inline void InvitationTarget::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.InvitationTarget.battle_tag)
+}
+inline void InvitationTarget::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.InvitationTarget.battle_tag)
+}
+inline ::std::string* InvitationTarget::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.InvitationTarget.battle_tag)
+  return battle_tag_;
+}
+inline ::std::string* InvitationTarget::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 InvitationTarget::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.InvitationTarget.battle_tag)
+}
+
+// -------------------------------------------------------------------
+
+// InvitationParams
+
+// optional string invitation_message = 1;
+inline bool InvitationParams::has_invitation_message() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void InvitationParams::set_has_invitation_message() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void InvitationParams::clear_has_invitation_message() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void InvitationParams::clear_invitation_message() {
+  if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitation_message_->clear();
+  }
+  clear_has_invitation_message();
+}
+inline const ::std::string& InvitationParams::invitation_message() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationParams.invitation_message)
+  return *invitation_message_;
+}
+inline void InvitationParams::set_invitation_message(const ::std::string& value) {
+  set_has_invitation_message();
+  if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitation_message_ = new ::std::string;
+  }
+  invitation_message_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.InvitationParams.invitation_message)
+}
+inline void InvitationParams::set_invitation_message(const char* value) {
+  set_has_invitation_message();
+  if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitation_message_ = new ::std::string;
+  }
+  invitation_message_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.InvitationParams.invitation_message)
+}
+inline void InvitationParams::set_invitation_message(const char* value, size_t size) {
+  set_has_invitation_message();
+  if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitation_message_ = new ::std::string;
+  }
+  invitation_message_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.InvitationParams.invitation_message)
+}
+inline ::std::string* InvitationParams::mutable_invitation_message() {
+  set_has_invitation_message();
+  if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitation_message_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.InvitationParams.invitation_message)
+  return invitation_message_;
+}
+inline ::std::string* InvitationParams::release_invitation_message() {
+  clear_has_invitation_message();
+  if (invitation_message_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = invitation_message_;
+    invitation_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void InvitationParams::set_allocated_invitation_message(::std::string* invitation_message) {
+  if (invitation_message_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete invitation_message_;
+  }
+  if (invitation_message) {
+    set_has_invitation_message();
+    invitation_message_ = invitation_message;
+  } else {
+    clear_has_invitation_message();
+    invitation_message_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.InvitationParams.invitation_message)
+}
+
+// optional uint64 expiration_time = 2 [default = 0];
+inline bool InvitationParams::has_expiration_time() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void InvitationParams::set_has_expiration_time() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void InvitationParams::clear_has_expiration_time() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void InvitationParams::clear_expiration_time() {
+  expiration_time_ = GOOGLE_ULONGLONG(0);
+  clear_has_expiration_time();
+}
+inline ::google::protobuf::uint64 InvitationParams::expiration_time() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.InvitationParams.expiration_time)
+  return expiration_time_;
+}
+inline void InvitationParams::set_expiration_time(::google::protobuf::uint64 value) {
+  set_has_expiration_time();
+  expiration_time_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.InvitationParams.expiration_time)
+}
+
+// -------------------------------------------------------------------
+
+// SendInvitationRequest
+
+// optional .bgs.protocol.Identity agent_identity = 1;
+inline bool SendInvitationRequest::has_agent_identity() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SendInvitationRequest::set_has_agent_identity() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SendInvitationRequest::clear_has_agent_identity() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SendInvitationRequest::clear_agent_identity() {
+  if (agent_identity_ != NULL) agent_identity_->::bgs::protocol::Identity::Clear();
+  clear_has_agent_identity();
+}
+inline const ::bgs::protocol::Identity& SendInvitationRequest::agent_identity() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationRequest.agent_identity)
+  return agent_identity_ != NULL ? *agent_identity_ : *default_instance_->agent_identity_;
+}
+inline ::bgs::protocol::Identity* SendInvitationRequest::mutable_agent_identity() {
+  set_has_agent_identity();
+  if (agent_identity_ == NULL) agent_identity_ = new ::bgs::protocol::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationRequest.agent_identity)
+  return agent_identity_;
+}
+inline ::bgs::protocol::Identity* SendInvitationRequest::release_agent_identity() {
+  clear_has_agent_identity();
+  ::bgs::protocol::Identity* temp = agent_identity_;
+  agent_identity_ = NULL;
+  return temp;
+}
+inline void SendInvitationRequest::set_allocated_agent_identity(::bgs::protocol::Identity* agent_identity) {
+  delete agent_identity_;
+  agent_identity_ = agent_identity;
+  if (agent_identity) {
+    set_has_agent_identity();
+  } else {
+    clear_has_agent_identity();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationRequest.agent_identity)
+}
+
+// required .bgs.protocol.EntityId target_id = 2 [deprecated = true];
+inline bool SendInvitationRequest::has_target_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SendInvitationRequest::set_has_target_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SendInvitationRequest::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SendInvitationRequest::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::EntityId& SendInvitationRequest::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationRequest.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::EntityId* SendInvitationRequest::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationRequest.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::EntityId* SendInvitationRequest::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::EntityId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void SendInvitationRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationRequest.target_id)
+}
+
+// required .bgs.protocol.InvitationParams params = 3;
+inline bool SendInvitationRequest::has_params() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SendInvitationRequest::set_has_params() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SendInvitationRequest::clear_has_params() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SendInvitationRequest::clear_params() {
+  if (params_ != NULL) params_->::bgs::protocol::InvitationParams::Clear();
+  clear_has_params();
+}
+inline const ::bgs::protocol::InvitationParams& SendInvitationRequest::params() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationRequest.params)
+  return params_ != NULL ? *params_ : *default_instance_->params_;
+}
+inline ::bgs::protocol::InvitationParams* SendInvitationRequest::mutable_params() {
+  set_has_params();
+  if (params_ == NULL) params_ = new ::bgs::protocol::InvitationParams;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationRequest.params)
+  return params_;
+}
+inline ::bgs::protocol::InvitationParams* SendInvitationRequest::release_params() {
+  clear_has_params();
+  ::bgs::protocol::InvitationParams* temp = params_;
+  params_ = NULL;
+  return temp;
+}
+inline void SendInvitationRequest::set_allocated_params(::bgs::protocol::InvitationParams* params) {
+  delete params_;
+  params_ = params;
+  if (params) {
+    set_has_params();
+  } else {
+    clear_has_params();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationRequest.params)
+}
+
+// optional .bgs.protocol.AccountInfo agent_info = 4;
+inline bool SendInvitationRequest::has_agent_info() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void SendInvitationRequest::set_has_agent_info() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void SendInvitationRequest::clear_has_agent_info() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void SendInvitationRequest::clear_agent_info() {
+  if (agent_info_ != NULL) agent_info_->::bgs::protocol::AccountInfo::Clear();
+  clear_has_agent_info();
+}
+inline const ::bgs::protocol::AccountInfo& SendInvitationRequest::agent_info() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationRequest.agent_info)
+  return agent_info_ != NULL ? *agent_info_ : *default_instance_->agent_info_;
+}
+inline ::bgs::protocol::AccountInfo* SendInvitationRequest::mutable_agent_info() {
+  set_has_agent_info();
+  if (agent_info_ == NULL) agent_info_ = new ::bgs::protocol::AccountInfo;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationRequest.agent_info)
+  return agent_info_;
+}
+inline ::bgs::protocol::AccountInfo* SendInvitationRequest::release_agent_info() {
+  clear_has_agent_info();
+  ::bgs::protocol::AccountInfo* temp = agent_info_;
+  agent_info_ = NULL;
+  return temp;
+}
+inline void SendInvitationRequest::set_allocated_agent_info(::bgs::protocol::AccountInfo* agent_info) {
+  delete agent_info_;
+  agent_info_ = agent_info;
+  if (agent_info) {
+    set_has_agent_info();
+  } else {
+    clear_has_agent_info();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationRequest.agent_info)
+}
+
+// optional .bgs.protocol.InvitationTarget target = 5;
+inline bool SendInvitationRequest::has_target() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void SendInvitationRequest::set_has_target() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void SendInvitationRequest::clear_has_target() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void SendInvitationRequest::clear_target() {
+  if (target_ != NULL) target_->::bgs::protocol::InvitationTarget::Clear();
+  clear_has_target();
+}
+inline const ::bgs::protocol::InvitationTarget& SendInvitationRequest::target() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationRequest.target)
+  return target_ != NULL ? *target_ : *default_instance_->target_;
+}
+inline ::bgs::protocol::InvitationTarget* SendInvitationRequest::mutable_target() {
+  set_has_target();
+  if (target_ == NULL) target_ = new ::bgs::protocol::InvitationTarget;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationRequest.target)
+  return target_;
+}
+inline ::bgs::protocol::InvitationTarget* SendInvitationRequest::release_target() {
+  clear_has_target();
+  ::bgs::protocol::InvitationTarget* temp = target_;
+  target_ = NULL;
+  return temp;
+}
+inline void SendInvitationRequest::set_allocated_target(::bgs::protocol::InvitationTarget* target) {
+  delete target_;
+  target_ = target;
+  if (target) {
+    set_has_target();
+  } else {
+    clear_has_target();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationRequest.target)
+}
+
+// -------------------------------------------------------------------
+
+// SendInvitationResponse
+
+// optional .bgs.protocol.Invitation invitation = 2;
+inline bool SendInvitationResponse::has_invitation() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SendInvitationResponse::set_has_invitation() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SendInvitationResponse::clear_has_invitation() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SendInvitationResponse::clear_invitation() {
+  if (invitation_ != NULL) invitation_->::bgs::protocol::Invitation::Clear();
+  clear_has_invitation();
+}
+inline const ::bgs::protocol::Invitation& SendInvitationResponse::invitation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.SendInvitationResponse.invitation)
+  return invitation_ != NULL ? *invitation_ : *default_instance_->invitation_;
+}
+inline ::bgs::protocol::Invitation* SendInvitationResponse::mutable_invitation() {
+  set_has_invitation();
+  if (invitation_ == NULL) invitation_ = new ::bgs::protocol::Invitation;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.SendInvitationResponse.invitation)
+  return invitation_;
+}
+inline ::bgs::protocol::Invitation* SendInvitationResponse::release_invitation() {
+  clear_has_invitation();
+  ::bgs::protocol::Invitation* temp = invitation_;
+  invitation_ = NULL;
+  return temp;
+}
+inline void SendInvitationResponse::set_allocated_invitation(::bgs::protocol::Invitation* invitation) {
+  delete invitation_;
+  invitation_ = invitation;
+  if (invitation) {
+    set_has_invitation();
+  } else {
+    clear_has_invitation();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SendInvitationResponse.invitation)
+}
+
+// -------------------------------------------------------------------
+
+// UpdateInvitationRequest
+
+// optional .bgs.protocol.Identity agent_identity = 1;
+inline bool UpdateInvitationRequest::has_agent_identity() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UpdateInvitationRequest::set_has_agent_identity() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UpdateInvitationRequest::clear_has_agent_identity() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UpdateInvitationRequest::clear_agent_identity() {
+  if (agent_identity_ != NULL) agent_identity_->::bgs::protocol::Identity::Clear();
+  clear_has_agent_identity();
+}
+inline const ::bgs::protocol::Identity& UpdateInvitationRequest::agent_identity() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.UpdateInvitationRequest.agent_identity)
+  return agent_identity_ != NULL ? *agent_identity_ : *default_instance_->agent_identity_;
+}
+inline ::bgs::protocol::Identity* UpdateInvitationRequest::mutable_agent_identity() {
+  set_has_agent_identity();
+  if (agent_identity_ == NULL) agent_identity_ = new ::bgs::protocol::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.UpdateInvitationRequest.agent_identity)
+  return agent_identity_;
+}
+inline ::bgs::protocol::Identity* UpdateInvitationRequest::release_agent_identity() {
+  clear_has_agent_identity();
+  ::bgs::protocol::Identity* temp = agent_identity_;
+  agent_identity_ = NULL;
+  return temp;
+}
+inline void UpdateInvitationRequest::set_allocated_agent_identity(::bgs::protocol::Identity* agent_identity) {
+  delete agent_identity_;
+  agent_identity_ = agent_identity;
+  if (agent_identity) {
+    set_has_agent_identity();
+  } else {
+    clear_has_agent_identity();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.UpdateInvitationRequest.agent_identity)
+}
+
+// required fixed64 invitation_id = 2;
+inline bool UpdateInvitationRequest::has_invitation_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UpdateInvitationRequest::set_has_invitation_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UpdateInvitationRequest::clear_has_invitation_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UpdateInvitationRequest::clear_invitation_id() {
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_invitation_id();
+}
+inline ::google::protobuf::uint64 UpdateInvitationRequest::invitation_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.UpdateInvitationRequest.invitation_id)
+  return invitation_id_;
+}
+inline void UpdateInvitationRequest::set_invitation_id(::google::protobuf::uint64 value) {
+  set_has_invitation_id();
+  invitation_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.UpdateInvitationRequest.invitation_id)
+}
+
+// required .bgs.protocol.InvitationParams params = 3;
+inline bool UpdateInvitationRequest::has_params() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void UpdateInvitationRequest::set_has_params() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void UpdateInvitationRequest::clear_has_params() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void UpdateInvitationRequest::clear_params() {
+  if (params_ != NULL) params_->::bgs::protocol::InvitationParams::Clear();
+  clear_has_params();
+}
+inline const ::bgs::protocol::InvitationParams& UpdateInvitationRequest::params() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.UpdateInvitationRequest.params)
+  return params_ != NULL ? *params_ : *default_instance_->params_;
+}
+inline ::bgs::protocol::InvitationParams* UpdateInvitationRequest::mutable_params() {
+  set_has_params();
+  if (params_ == NULL) params_ = new ::bgs::protocol::InvitationParams;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.UpdateInvitationRequest.params)
+  return params_;
+}
+inline ::bgs::protocol::InvitationParams* UpdateInvitationRequest::release_params() {
+  clear_has_params();
+  ::bgs::protocol::InvitationParams* temp = params_;
+  params_ = NULL;
+  return temp;
+}
+inline void UpdateInvitationRequest::set_allocated_params(::bgs::protocol::InvitationParams* params) {
+  delete params_;
+  params_ = params;
+  if (params) {
+    set_has_params();
+  } else {
+    clear_has_params();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.UpdateInvitationRequest.params)
+}
+
+// -------------------------------------------------------------------
+
+// GenericInvitationRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool GenericInvitationRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GenericInvitationRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GenericInvitationRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GenericInvitationRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& GenericInvitationRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* GenericInvitationRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.GenericInvitationRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* GenericInvitationRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void GenericInvitationRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.GenericInvitationRequest.agent_id)
+}
+
+// optional .bgs.protocol.EntityId target_id = 2;
+inline bool GenericInvitationRequest::has_target_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GenericInvitationRequest::set_has_target_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GenericInvitationRequest::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GenericInvitationRequest::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::EntityId& GenericInvitationRequest::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::EntityId* GenericInvitationRequest::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.GenericInvitationRequest.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::EntityId* GenericInvitationRequest::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::EntityId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void GenericInvitationRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.GenericInvitationRequest.target_id)
+}
+
+// required fixed64 invitation_id = 3;
+inline bool GenericInvitationRequest::has_invitation_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GenericInvitationRequest::set_has_invitation_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GenericInvitationRequest::clear_has_invitation_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GenericInvitationRequest::clear_invitation_id() {
+  invitation_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_invitation_id();
+}
+inline ::google::protobuf::uint64 GenericInvitationRequest::invitation_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.invitation_id)
+  return invitation_id_;
+}
+inline void GenericInvitationRequest::set_invitation_id(::google::protobuf::uint64 value) {
+  set_has_invitation_id();
+  invitation_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.invitation_id)
+}
+
+// optional string invitee_name = 4;
+inline bool GenericInvitationRequest::has_invitee_name() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void GenericInvitationRequest::set_has_invitee_name() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void GenericInvitationRequest::clear_has_invitee_name() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void GenericInvitationRequest::clear_invitee_name() {
+  if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_name_->clear();
+  }
+  clear_has_invitee_name();
+}
+inline const ::std::string& GenericInvitationRequest::invitee_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.invitee_name)
+  return *invitee_name_;
+}
+inline void GenericInvitationRequest::set_invitee_name(const ::std::string& value) {
+  set_has_invitee_name();
+  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_name_ = new ::std::string;
+  }
+  invitee_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.invitee_name)
+}
+inline void GenericInvitationRequest::set_invitee_name(const char* value) {
+  set_has_invitee_name();
+  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_name_ = new ::std::string;
+  }
+  invitee_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.GenericInvitationRequest.invitee_name)
+}
+inline void GenericInvitationRequest::set_invitee_name(const char* value, size_t size) {
+  set_has_invitee_name();
+  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_name_ = new ::std::string;
+  }
+  invitee_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.GenericInvitationRequest.invitee_name)
+}
+inline ::std::string* GenericInvitationRequest::mutable_invitee_name() {
+  set_has_invitee_name();
+  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    invitee_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.GenericInvitationRequest.invitee_name)
+  return invitee_name_;
+}
+inline ::std::string* GenericInvitationRequest::release_invitee_name() {
+  clear_has_invitee_name();
+  if (invitee_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = invitee_name_;
+    invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void GenericInvitationRequest::set_allocated_invitee_name(::std::string* invitee_name) {
+  if (invitee_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete invitee_name_;
+  }
+  if (invitee_name) {
+    set_has_invitee_name();
+    invitee_name_ = invitee_name;
+  } else {
+    clear_has_invitee_name();
+    invitee_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.GenericInvitationRequest.invitee_name)
+}
+
+// optional string inviter_name = 5;
+inline bool GenericInvitationRequest::has_inviter_name() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void GenericInvitationRequest::set_has_inviter_name() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void GenericInvitationRequest::clear_has_inviter_name() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void GenericInvitationRequest::clear_inviter_name() {
+  if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_name_->clear();
+  }
+  clear_has_inviter_name();
+}
+inline const ::std::string& GenericInvitationRequest::inviter_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.inviter_name)
+  return *inviter_name_;
+}
+inline void GenericInvitationRequest::set_inviter_name(const ::std::string& value) {
+  set_has_inviter_name();
+  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_name_ = new ::std::string;
+  }
+  inviter_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.inviter_name)
+}
+inline void GenericInvitationRequest::set_inviter_name(const char* value) {
+  set_has_inviter_name();
+  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_name_ = new ::std::string;
+  }
+  inviter_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.GenericInvitationRequest.inviter_name)
+}
+inline void GenericInvitationRequest::set_inviter_name(const char* value, size_t size) {
+  set_has_inviter_name();
+  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_name_ = new ::std::string;
+  }
+  inviter_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.GenericInvitationRequest.inviter_name)
+}
+inline ::std::string* GenericInvitationRequest::mutable_inviter_name() {
+  set_has_inviter_name();
+  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    inviter_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.GenericInvitationRequest.inviter_name)
+  return inviter_name_;
+}
+inline ::std::string* GenericInvitationRequest::release_inviter_name() {
+  clear_has_inviter_name();
+  if (inviter_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = inviter_name_;
+    inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void GenericInvitationRequest::set_allocated_inviter_name(::std::string* inviter_name) {
+  if (inviter_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete inviter_name_;
+  }
+  if (inviter_name) {
+    set_has_inviter_name();
+    inviter_name_ = inviter_name;
+  } else {
+    clear_has_inviter_name();
+    inviter_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.GenericInvitationRequest.inviter_name)
+}
+
+// repeated uint32 previous_role = 6 [packed = true];
+inline int GenericInvitationRequest::previous_role_size() const {
+  return previous_role_.size();
+}
+inline void GenericInvitationRequest::clear_previous_role() {
+  previous_role_.Clear();
+}
+inline ::google::protobuf::uint32 GenericInvitationRequest::previous_role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.previous_role)
+  return previous_role_.Get(index);
+}
+inline void GenericInvitationRequest::set_previous_role(int index, ::google::protobuf::uint32 value) {
+  previous_role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.previous_role)
+}
+inline void GenericInvitationRequest::add_previous_role(::google::protobuf::uint32 value) {
+  previous_role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.GenericInvitationRequest.previous_role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+GenericInvitationRequest::previous_role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.GenericInvitationRequest.previous_role)
+  return previous_role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+GenericInvitationRequest::mutable_previous_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.GenericInvitationRequest.previous_role)
+  return &previous_role_;
+}
+
+// repeated uint32 desired_role = 7 [packed = true];
+inline int GenericInvitationRequest::desired_role_size() const {
+  return desired_role_.size();
+}
+inline void GenericInvitationRequest::clear_desired_role() {
+  desired_role_.Clear();
+}
+inline ::google::protobuf::uint32 GenericInvitationRequest::desired_role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.desired_role)
+  return desired_role_.Get(index);
+}
+inline void GenericInvitationRequest::set_desired_role(int index, ::google::protobuf::uint32 value) {
+  desired_role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.desired_role)
+}
+inline void GenericInvitationRequest::add_desired_role(::google::protobuf::uint32 value) {
+  desired_role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.GenericInvitationRequest.desired_role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+GenericInvitationRequest::desired_role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.GenericInvitationRequest.desired_role)
+  return desired_role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+GenericInvitationRequest::mutable_desired_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.GenericInvitationRequest.desired_role)
+  return &desired_role_;
+}
+
+// optional uint32 reason = 8;
+inline bool GenericInvitationRequest::has_reason() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void GenericInvitationRequest::set_has_reason() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void GenericInvitationRequest::clear_has_reason() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void GenericInvitationRequest::clear_reason() {
+  reason_ = 0u;
+  clear_has_reason();
+}
+inline ::google::protobuf::uint32 GenericInvitationRequest::reason() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.GenericInvitationRequest.reason)
+  return reason_;
+}
+inline void GenericInvitationRequest::set_reason(::google::protobuf::uint32 value) {
+  set_has_reason();
+  reason_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.GenericInvitationRequest.reason)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_invitation_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/notification_types.pb.cc b/src/server/proto/Client/notification_types.pb.cc
new file mode 100644
index 00000000000..1f354557075
--- /dev/null
+++ b/src/server/proto/Client/notification_types.pb.cc
@@ -0,0 +1,1490 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: notification_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "notification_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace notification {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* Target_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Target_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Subscription_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Subscription_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Notification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Notification_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_notification_5ftypes_2eproto() {
+  protobuf_AddDesc_notification_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "notification_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  Target_descriptor_ = file->message_type(0);
+  static const int Target_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Target, identity_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Target, type_),
+  };
+  Target_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Target_descriptor_,
+      Target::default_instance_,
+      Target_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Target, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Target, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Target));
+  Subscription_descriptor_ = file->message_type(1);
+  static const int Subscription_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Subscription, target_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Subscription, subscriber_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Subscription, delivery_required_),
+  };
+  Subscription_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Subscription_descriptor_,
+      Subscription::default_instance_,
+      Subscription_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Subscription, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Subscription, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Subscription));
+  Notification_descriptor_ = file->message_type(2);
+  static const int Notification_offsets_[10] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, sender_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, target_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, sender_account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, target_account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, sender_battle_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, target_battle_tag_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, peer_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, forwarding_identity_),
+  };
+  Notification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Notification_descriptor_,
+      Notification::default_instance_,
+      Notification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Notification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Notification));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_notification_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Target_descriptor_, &Target::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Subscription_descriptor_, &Subscription::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Notification_descriptor_, &Notification::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_notification_5ftypes_2eproto() {
+  delete Target::default_instance_;
+  delete Target_reflection_;
+  delete Subscription::default_instance_;
+  delete Subscription_reflection_;
+  delete Notification::default_instance_;
+  delete Notification_reflection_;
+}
+
+void protobuf_AddDesc_notification_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::account::v1::protobuf_AddDesc_account_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\030notification_types.proto\022\034bgs.protocol"
+    ".notification.v1\032\023account_types.proto\032\025a"
+    "ttribute_types.proto\032\022entity_types.proto"
+    "\032\017rpc_types.proto\"K\n\006Target\0223\n\010identity\030"
+    "\001 \001(\0132!.bgs.protocol.account.v1.Identity"
+    "\022\014\n\004type\030\002 \001(\t\"\235\001\n\014Subscription\0224\n\006targe"
+    "t\030\001 \003(\0132$.bgs.protocol.notification.v1.T"
+    "arget\0225\n\nsubscriber\030\002 \001(\0132!.bgs.protocol"
+    ".account.v1.Identity\022 \n\021delivery_require"
+    "d\030\003 \001(\010:\005false\"\241\003\n\014Notification\022)\n\tsende"
+    "r_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022)\n\tta"
+    "rget_id\030\002 \002(\0132\026.bgs.protocol.EntityId\022\014\n"
+    "\004type\030\003 \002(\t\022*\n\tattribute\030\004 \003(\0132\027.bgs.pro"
+    "tocol.Attribute\0221\n\021sender_account_id\030\005 \001"
+    "(\0132\026.bgs.protocol.EntityId\0221\n\021target_acc"
+    "ount_id\030\006 \001(\0132\026.bgs.protocol.EntityId\022\031\n"
+    "\021sender_battle_tag\030\007 \001(\t\022\031\n\021target_battl"
+    "e_tag\030\010 \001(\t\022%\n\004peer\030\t \001(\0132\027.bgs.protocol"
+    ".ProcessId\022>\n\023forwarding_identity\030\n \001(\0132"
+    "!.bgs.protocol.account.v1.IdentityB\002H\001", 798);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "notification_types.proto", &protobuf_RegisterTypes);
+  Target::default_instance_ = new Target();
+  Subscription::default_instance_ = new Subscription();
+  Notification::default_instance_ = new Notification();
+  Target::default_instance_->InitAsDefaultInstance();
+  Subscription::default_instance_->InitAsDefaultInstance();
+  Notification::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_notification_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_notification_5ftypes_2eproto {
+  StaticDescriptorInitializer_notification_5ftypes_2eproto() {
+    protobuf_AddDesc_notification_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_notification_5ftypes_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Target::kIdentityFieldNumber;
+const int Target::kTypeFieldNumber;
+#endif  // !_MSC_VER
+
+Target::Target()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.notification.v1.Target)
+}
+
+void Target::InitAsDefaultInstance() {
+  identity_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
+}
+
+Target::Target(const Target& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.notification.v1.Target)
+}
+
+void Target::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  identity_ = NULL;
+  type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Target::~Target() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.notification.v1.Target)
+  SharedDtor();
+}
+
+void Target::SharedDtor() {
+  if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete type_;
+  }
+  if (this != default_instance_) {
+    delete identity_;
+  }
+}
+
+void Target::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Target::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Target_descriptor_;
+}
+
+const Target& Target::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_notification_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Target* Target::default_instance_ = NULL;
+
+Target* Target::New() const {
+  return new Target;
+}
+
+void Target::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_identity()) {
+      if (identity_ != NULL) identity_->::bgs::protocol::account::v1::Identity::Clear();
+    }
+    if (has_type()) {
+      if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        type_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Target::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.notification.v1.Target)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.account.v1.Identity identity = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_identity()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_type;
+        break;
+      }
+
+      // optional string type = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_type:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_type()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->type().data(), this->type().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "type");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.notification.v1.Target)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.notification.v1.Target)
+  return false;
+#undef DO_
+}
+
+void Target::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.notification.v1.Target)
+  // optional .bgs.protocol.account.v1.Identity identity = 1;
+  if (has_identity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->identity(), output);
+  }
+
+  // optional string type = 2;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->type().data(), this->type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "type");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->type(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.notification.v1.Target)
+}
+
+::google::protobuf::uint8* Target::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.notification.v1.Target)
+  // optional .bgs.protocol.account.v1.Identity identity = 1;
+  if (has_identity()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->identity(), target);
+  }
+
+  // optional string type = 2;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->type().data(), this->type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "type");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->type(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.notification.v1.Target)
+  return target;
+}
+
+int Target::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.account.v1.Identity identity = 1;
+    if (has_identity()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->identity());
+    }
+
+    // optional string type = 2;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->type());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Target::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Target* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Target*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Target::MergeFrom(const Target& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_identity()) {
+      mutable_identity()->::bgs::protocol::account::v1::Identity::MergeFrom(from.identity());
+    }
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Target::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Target::CopyFrom(const Target& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Target::IsInitialized() const {
+
+  if (has_identity()) {
+    if (!this->identity().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void Target::Swap(Target* other) {
+  if (other != this) {
+    std::swap(identity_, other->identity_);
+    std::swap(type_, other->type_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Target::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Target_descriptor_;
+  metadata.reflection = Target_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Subscription::kTargetFieldNumber;
+const int Subscription::kSubscriberFieldNumber;
+const int Subscription::kDeliveryRequiredFieldNumber;
+#endif  // !_MSC_VER
+
+Subscription::Subscription()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.notification.v1.Subscription)
+}
+
+void Subscription::InitAsDefaultInstance() {
+  subscriber_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
+}
+
+Subscription::Subscription(const Subscription& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.notification.v1.Subscription)
+}
+
+void Subscription::SharedCtor() {
+  _cached_size_ = 0;
+  subscriber_ = NULL;
+  delivery_required_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Subscription::~Subscription() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.notification.v1.Subscription)
+  SharedDtor();
+}
+
+void Subscription::SharedDtor() {
+  if (this != default_instance_) {
+    delete subscriber_;
+  }
+}
+
+void Subscription::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Subscription::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Subscription_descriptor_;
+}
+
+const Subscription& Subscription::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_notification_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Subscription* Subscription::default_instance_ = NULL;
+
+Subscription* Subscription::New() const {
+  return new Subscription;
+}
+
+void Subscription::Clear() {
+  if (_has_bits_[0 / 32] & 6) {
+    if (has_subscriber()) {
+      if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
+    }
+    delivery_required_ = false;
+  }
+  target_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Subscription::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.notification.v1.Subscription)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.notification.v1.Target target = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_target:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_target()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_target;
+        if (input->ExpectTag(18)) goto parse_subscriber;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.Identity subscriber = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_subscriber:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_subscriber()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_delivery_required;
+        break;
+      }
+
+      // optional bool delivery_required = 3 [default = false];
+      case 3: {
+        if (tag == 24) {
+         parse_delivery_required:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &delivery_required_)));
+          set_has_delivery_required();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.notification.v1.Subscription)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.notification.v1.Subscription)
+  return false;
+#undef DO_
+}
+
+void Subscription::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.notification.v1.Subscription)
+  // repeated .bgs.protocol.notification.v1.Target target = 1;
+  for (int i = 0; i < this->target_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->target(i), output);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 2;
+  if (has_subscriber()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->subscriber(), output);
+  }
+
+  // optional bool delivery_required = 3 [default = false];
+  if (has_delivery_required()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->delivery_required(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.notification.v1.Subscription)
+}
+
+::google::protobuf::uint8* Subscription::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.notification.v1.Subscription)
+  // repeated .bgs.protocol.notification.v1.Target target = 1;
+  for (int i = 0; i < this->target_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->target(i), target);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 2;
+  if (has_subscriber()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->subscriber(), target);
+  }
+
+  // optional bool delivery_required = 3 [default = false];
+  if (has_delivery_required()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->delivery_required(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.notification.v1.Subscription)
+  return target;
+}
+
+int Subscription::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional .bgs.protocol.account.v1.Identity subscriber = 2;
+    if (has_subscriber()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->subscriber());
+    }
+
+    // optional bool delivery_required = 3 [default = false];
+    if (has_delivery_required()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated .bgs.protocol.notification.v1.Target target = 1;
+  total_size += 1 * this->target_size();
+  for (int i = 0; i < this->target_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->target(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Subscription::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Subscription* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Subscription*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Subscription::MergeFrom(const Subscription& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  target_.MergeFrom(from.target_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_subscriber()) {
+      mutable_subscriber()->::bgs::protocol::account::v1::Identity::MergeFrom(from.subscriber());
+    }
+    if (from.has_delivery_required()) {
+      set_delivery_required(from.delivery_required());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Subscription::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Subscription::CopyFrom(const Subscription& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Subscription::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->target())) return false;
+  if (has_subscriber()) {
+    if (!this->subscriber().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void Subscription::Swap(Subscription* other) {
+  if (other != this) {
+    target_.Swap(&other->target_);
+    std::swap(subscriber_, other->subscriber_);
+    std::swap(delivery_required_, other->delivery_required_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Subscription::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Subscription_descriptor_;
+  metadata.reflection = Subscription_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Notification::kSenderIdFieldNumber;
+const int Notification::kTargetIdFieldNumber;
+const int Notification::kTypeFieldNumber;
+const int Notification::kAttributeFieldNumber;
+const int Notification::kSenderAccountIdFieldNumber;
+const int Notification::kTargetAccountIdFieldNumber;
+const int Notification::kSenderBattleTagFieldNumber;
+const int Notification::kTargetBattleTagFieldNumber;
+const int Notification::kPeerFieldNumber;
+const int Notification::kForwardingIdentityFieldNumber;
+#endif  // !_MSC_VER
+
+Notification::Notification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.notification.v1.Notification)
+}
+
+void Notification::InitAsDefaultInstance() {
+  sender_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  sender_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  target_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  peer_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+  forwarding_identity_ = const_cast< ::bgs::protocol::account::v1::Identity*>(&::bgs::protocol::account::v1::Identity::default_instance());
+}
+
+Notification::Notification(const Notification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.notification.v1.Notification)
+}
+
+void Notification::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  sender_id_ = NULL;
+  target_id_ = NULL;
+  type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  sender_account_id_ = NULL;
+  target_account_id_ = NULL;
+  sender_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  target_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  peer_ = NULL;
+  forwarding_identity_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Notification::~Notification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.notification.v1.Notification)
+  SharedDtor();
+}
+
+void Notification::SharedDtor() {
+  if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete type_;
+  }
+  if (sender_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete sender_battle_tag_;
+  }
+  if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete target_battle_tag_;
+  }
+  if (this != default_instance_) {
+    delete sender_id_;
+    delete target_id_;
+    delete sender_account_id_;
+    delete target_account_id_;
+    delete peer_;
+    delete forwarding_identity_;
+  }
+}
+
+void Notification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Notification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Notification_descriptor_;
+}
+
+const Notification& Notification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_notification_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Notification* Notification::default_instance_ = NULL;
+
+Notification* Notification::New() const {
+  return new Notification;
+}
+
+void Notification::Clear() {
+  if (_has_bits_[0 / 32] & 247) {
+    if (has_sender_id()) {
+      if (sender_id_ != NULL) sender_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_type()) {
+      if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        type_->clear();
+      }
+    }
+    if (has_sender_account_id()) {
+      if (sender_account_id_ != NULL) sender_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_target_account_id()) {
+      if (target_account_id_ != NULL) target_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_sender_battle_tag()) {
+      if (sender_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        sender_battle_tag_->clear();
+      }
+    }
+    if (has_target_battle_tag()) {
+      if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        target_battle_tag_->clear();
+      }
+    }
+  }
+  if (_has_bits_[8 / 32] & 768) {
+    if (has_peer()) {
+      if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear();
+    }
+    if (has_forwarding_identity()) {
+      if (forwarding_identity_ != NULL) forwarding_identity_->::bgs::protocol::account::v1::Identity::Clear();
+    }
+  }
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Notification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.notification.v1.Notification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId sender_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_sender_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_target_id;
+        break;
+      }
+
+      // required .bgs.protocol.EntityId target_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_target_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_type;
+        break;
+      }
+
+      // required string type = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_type:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_type()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->type().data(), this->type().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "type");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.Attribute attribute = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_attribute;
+        if (input->ExpectTag(42)) goto parse_sender_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId sender_account_id = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_sender_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_sender_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_target_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId target_account_id = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_target_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_sender_battle_tag;
+        break;
+      }
+
+      // optional string sender_battle_tag = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_sender_battle_tag:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_sender_battle_tag()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->sender_battle_tag().data(), this->sender_battle_tag().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "sender_battle_tag");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_target_battle_tag;
+        break;
+      }
+
+      // optional string target_battle_tag = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_target_battle_tag:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_target_battle_tag()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->target_battle_tag().data(), this->target_battle_tag().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "target_battle_tag");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(74)) goto parse_peer;
+        break;
+      }
+
+      // optional .bgs.protocol.ProcessId peer = 9;
+      case 9: {
+        if (tag == 74) {
+         parse_peer:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_peer()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_forwarding_identity;
+        break;
+      }
+
+      // optional .bgs.protocol.account.v1.Identity forwarding_identity = 10;
+      case 10: {
+        if (tag == 82) {
+         parse_forwarding_identity:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_forwarding_identity()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.notification.v1.Notification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.notification.v1.Notification)
+  return false;
+#undef DO_
+}
+
+void Notification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.notification.v1.Notification)
+  // optional .bgs.protocol.EntityId sender_id = 1;
+  if (has_sender_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->sender_id(), output);
+  }
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->target_id(), output);
+  }
+
+  // required string type = 3;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->type().data(), this->type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "type");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      3, this->type(), output);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 4;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->attribute(i), output);
+  }
+
+  // optional .bgs.protocol.EntityId sender_account_id = 5;
+  if (has_sender_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->sender_account_id(), output);
+  }
+
+  // optional .bgs.protocol.EntityId target_account_id = 6;
+  if (has_target_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      6, this->target_account_id(), output);
+  }
+
+  // optional string sender_battle_tag = 7;
+  if (has_sender_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->sender_battle_tag().data(), this->sender_battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "sender_battle_tag");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      7, this->sender_battle_tag(), output);
+  }
+
+  // optional string target_battle_tag = 8;
+  if (has_target_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->target_battle_tag().data(), this->target_battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "target_battle_tag");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      8, this->target_battle_tag(), output);
+  }
+
+  // optional .bgs.protocol.ProcessId peer = 9;
+  if (has_peer()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      9, this->peer(), output);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity forwarding_identity = 10;
+  if (has_forwarding_identity()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      10, this->forwarding_identity(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.notification.v1.Notification)
+}
+
+::google::protobuf::uint8* Notification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.notification.v1.Notification)
+  // optional .bgs.protocol.EntityId sender_id = 1;
+  if (has_sender_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->sender_id(), target);
+  }
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->target_id(), target);
+  }
+
+  // required string type = 3;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->type().data(), this->type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "type");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        3, this->type(), target);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 4;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->attribute(i), target);
+  }
+
+  // optional .bgs.protocol.EntityId sender_account_id = 5;
+  if (has_sender_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->sender_account_id(), target);
+  }
+
+  // optional .bgs.protocol.EntityId target_account_id = 6;
+  if (has_target_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        6, this->target_account_id(), target);
+  }
+
+  // optional string sender_battle_tag = 7;
+  if (has_sender_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->sender_battle_tag().data(), this->sender_battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "sender_battle_tag");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        7, this->sender_battle_tag(), target);
+  }
+
+  // optional string target_battle_tag = 8;
+  if (has_target_battle_tag()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->target_battle_tag().data(), this->target_battle_tag().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "target_battle_tag");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        8, this->target_battle_tag(), target);
+  }
+
+  // optional .bgs.protocol.ProcessId peer = 9;
+  if (has_peer()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        9, this->peer(), target);
+  }
+
+  // optional .bgs.protocol.account.v1.Identity forwarding_identity = 10;
+  if (has_forwarding_identity()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        10, this->forwarding_identity(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.notification.v1.Notification)
+  return target;
+}
+
+int Notification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId sender_id = 1;
+    if (has_sender_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->sender_id());
+    }
+
+    // required .bgs.protocol.EntityId target_id = 2;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+    // required string type = 3;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->type());
+    }
+
+    // optional .bgs.protocol.EntityId sender_account_id = 5;
+    if (has_sender_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->sender_account_id());
+    }
+
+    // optional .bgs.protocol.EntityId target_account_id = 6;
+    if (has_target_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_account_id());
+    }
+
+    // optional string sender_battle_tag = 7;
+    if (has_sender_battle_tag()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->sender_battle_tag());
+    }
+
+    // optional string target_battle_tag = 8;
+    if (has_target_battle_tag()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->target_battle_tag());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional .bgs.protocol.ProcessId peer = 9;
+    if (has_peer()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->peer());
+    }
+
+    // optional .bgs.protocol.account.v1.Identity forwarding_identity = 10;
+    if (has_forwarding_identity()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->forwarding_identity());
+    }
+
+  }
+  // repeated .bgs.protocol.Attribute attribute = 4;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Notification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Notification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Notification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Notification::MergeFrom(const Notification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_sender_id()) {
+      mutable_sender_id()->::bgs::protocol::EntityId::MergeFrom(from.sender_id());
+    }
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id());
+    }
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_sender_account_id()) {
+      mutable_sender_account_id()->::bgs::protocol::EntityId::MergeFrom(from.sender_account_id());
+    }
+    if (from.has_target_account_id()) {
+      mutable_target_account_id()->::bgs::protocol::EntityId::MergeFrom(from.target_account_id());
+    }
+    if (from.has_sender_battle_tag()) {
+      set_sender_battle_tag(from.sender_battle_tag());
+    }
+    if (from.has_target_battle_tag()) {
+      set_target_battle_tag(from.target_battle_tag());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_peer()) {
+      mutable_peer()->::bgs::protocol::ProcessId::MergeFrom(from.peer());
+    }
+    if (from.has_forwarding_identity()) {
+      mutable_forwarding_identity()->::bgs::protocol::account::v1::Identity::MergeFrom(from.forwarding_identity());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Notification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Notification::CopyFrom(const Notification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Notification::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false;
+
+  if (has_sender_id()) {
+    if (!this->sender_id().IsInitialized()) return false;
+  }
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
+  if (has_sender_account_id()) {
+    if (!this->sender_account_id().IsInitialized()) return false;
+  }
+  if (has_target_account_id()) {
+    if (!this->target_account_id().IsInitialized()) return false;
+  }
+  if (has_peer()) {
+    if (!this->peer().IsInitialized()) return false;
+  }
+  if (has_forwarding_identity()) {
+    if (!this->forwarding_identity().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void Notification::Swap(Notification* other) {
+  if (other != this) {
+    std::swap(sender_id_, other->sender_id_);
+    std::swap(target_id_, other->target_id_);
+    std::swap(type_, other->type_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(sender_account_id_, other->sender_account_id_);
+    std::swap(target_account_id_, other->target_account_id_);
+    std::swap(sender_battle_tag_, other->sender_battle_tag_);
+    std::swap(target_battle_tag_, other->target_battle_tag_);
+    std::swap(peer_, other->peer_);
+    std::swap(forwarding_identity_, other->forwarding_identity_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Notification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Notification_descriptor_;
+  metadata.reflection = Notification_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace notification
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/notification_types.pb.h b/src/server/proto/Client/notification_types.pb.h
new file mode 100644
index 00000000000..e0cf8d6c157
--- /dev/null
+++ b/src/server/proto/Client/notification_types.pb.h
@@ -0,0 +1,1200 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: notification_types.proto
+
+#ifndef PROTOBUF_notification_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_notification_5ftypes_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 "attribute_types.pb.h"
+#include "entity_types.pb.h"
+#include "rpc_types.pb.h"
+#include "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace notification {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_notification_5ftypes_2eproto();
+void protobuf_AssignDesc_notification_5ftypes_2eproto();
+void protobuf_ShutdownFile_notification_5ftypes_2eproto();
+
+class Target;
+class Subscription;
+class Notification;
+
+// ===================================================================
+
+class TC_SHARED_API Target : public ::google::protobuf::Message {
+ public:
+  Target();
+  virtual ~Target();
+
+  Target(const Target& from);
+
+  inline Target& operator=(const Target& 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 Target& default_instance();
+
+  void Swap(Target* other);
+
+  // implements Message ----------------------------------------------
+
+  Target* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Target& from);
+  void MergeFrom(const Target& 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.account.v1.Identity identity = 1;
+  inline bool has_identity() const;
+  inline void clear_identity();
+  static const int kIdentityFieldNumber = 1;
+  inline const ::bgs::protocol::account::v1::Identity& identity() const;
+  inline ::bgs::protocol::account::v1::Identity* mutable_identity();
+  inline ::bgs::protocol::account::v1::Identity* release_identity();
+  inline void set_allocated_identity(::bgs::protocol::account::v1::Identity* identity);
+
+  // optional string type = 2;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 2;
+  inline const ::std::string& type() const;
+  inline void set_type(const ::std::string& value);
+  inline void set_type(const char* value);
+  inline void set_type(const char* value, size_t size);
+  inline ::std::string* mutable_type();
+  inline ::std::string* release_type();
+  inline void set_allocated_type(::std::string* type);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.notification.v1.Target)
+ private:
+  inline void set_has_identity();
+  inline void clear_has_identity();
+  inline void set_has_type();
+  inline void clear_has_type();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::account::v1::Identity* identity_;
+  ::std::string* type_;
+  friend void TC_SHARED_API protobuf_AddDesc_notification_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_notification_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_notification_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Target* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API Subscription : public ::google::protobuf::Message {
+ public:
+  Subscription();
+  virtual ~Subscription();
+
+  Subscription(const Subscription& from);
+
+  inline Subscription& operator=(const Subscription& 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 Subscription& default_instance();
+
+  void Swap(Subscription* other);
+
+  // implements Message ----------------------------------------------
+
+  Subscription* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Subscription& from);
+  void MergeFrom(const Subscription& 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.notification.v1.Target target = 1;
+  inline int target_size() const;
+  inline void clear_target();
+  static const int kTargetFieldNumber = 1;
+  inline const ::bgs::protocol::notification::v1::Target& target(int index) const;
+  inline ::bgs::protocol::notification::v1::Target* mutable_target(int index);
+  inline ::bgs::protocol::notification::v1::Target* add_target();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::notification::v1::Target >&
+      target() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::notification::v1::Target >*
+      mutable_target();
+
+  // optional .bgs.protocol.account.v1.Identity subscriber = 2;
+  inline bool has_subscriber() const;
+  inline void clear_subscriber();
+  static const int kSubscriberFieldNumber = 2;
+  inline const ::bgs::protocol::account::v1::Identity& subscriber() const;
+  inline ::bgs::protocol::account::v1::Identity* mutable_subscriber();
+  inline ::bgs::protocol::account::v1::Identity* release_subscriber();
+  inline void set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber);
+
+  // optional bool delivery_required = 3 [default = false];
+  inline bool has_delivery_required() const;
+  inline void clear_delivery_required();
+  static const int kDeliveryRequiredFieldNumber = 3;
+  inline bool delivery_required() const;
+  inline void set_delivery_required(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.notification.v1.Subscription)
+ private:
+  inline void set_has_subscriber();
+  inline void clear_has_subscriber();
+  inline void set_has_delivery_required();
+  inline void clear_has_delivery_required();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::notification::v1::Target > target_;
+  ::bgs::protocol::account::v1::Identity* subscriber_;
+  bool delivery_required_;
+  friend void TC_SHARED_API protobuf_AddDesc_notification_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_notification_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_notification_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Subscription* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API Notification : public ::google::protobuf::Message {
+ public:
+  Notification();
+  virtual ~Notification();
+
+  Notification(const Notification& from);
+
+  inline Notification& operator=(const Notification& 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 Notification& default_instance();
+
+  void Swap(Notification* other);
+
+  // implements Message ----------------------------------------------
+
+  Notification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Notification& from);
+  void MergeFrom(const Notification& 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.EntityId sender_id = 1;
+  inline bool has_sender_id() const;
+  inline void clear_sender_id();
+  static const int kSenderIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& sender_id() const;
+  inline ::bgs::protocol::EntityId* mutable_sender_id();
+  inline ::bgs::protocol::EntityId* release_sender_id();
+  inline void set_allocated_sender_id(::bgs::protocol::EntityId* sender_id);
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& target_id() const;
+  inline ::bgs::protocol::EntityId* mutable_target_id();
+  inline ::bgs::protocol::EntityId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id);
+
+  // required string type = 3;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 3;
+  inline const ::std::string& type() const;
+  inline void set_type(const ::std::string& value);
+  inline void set_type(const char* value);
+  inline void set_type(const char* value, size_t size);
+  inline ::std::string* mutable_type();
+  inline ::std::string* release_type();
+  inline void set_allocated_type(::std::string* type);
+
+  // repeated .bgs.protocol.Attribute attribute = 4;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 4;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
+  // optional .bgs.protocol.EntityId sender_account_id = 5;
+  inline bool has_sender_account_id() const;
+  inline void clear_sender_account_id();
+  static const int kSenderAccountIdFieldNumber = 5;
+  inline const ::bgs::protocol::EntityId& sender_account_id() const;
+  inline ::bgs::protocol::EntityId* mutable_sender_account_id();
+  inline ::bgs::protocol::EntityId* release_sender_account_id();
+  inline void set_allocated_sender_account_id(::bgs::protocol::EntityId* sender_account_id);
+
+  // optional .bgs.protocol.EntityId target_account_id = 6;
+  inline bool has_target_account_id() const;
+  inline void clear_target_account_id();
+  static const int kTargetAccountIdFieldNumber = 6;
+  inline const ::bgs::protocol::EntityId& target_account_id() const;
+  inline ::bgs::protocol::EntityId* mutable_target_account_id();
+  inline ::bgs::protocol::EntityId* release_target_account_id();
+  inline void set_allocated_target_account_id(::bgs::protocol::EntityId* target_account_id);
+
+  // optional string sender_battle_tag = 7;
+  inline bool has_sender_battle_tag() const;
+  inline void clear_sender_battle_tag();
+  static const int kSenderBattleTagFieldNumber = 7;
+  inline const ::std::string& sender_battle_tag() const;
+  inline void set_sender_battle_tag(const ::std::string& value);
+  inline void set_sender_battle_tag(const char* value);
+  inline void set_sender_battle_tag(const char* value, size_t size);
+  inline ::std::string* mutable_sender_battle_tag();
+  inline ::std::string* release_sender_battle_tag();
+  inline void set_allocated_sender_battle_tag(::std::string* sender_battle_tag);
+
+  // optional string target_battle_tag = 8;
+  inline bool has_target_battle_tag() const;
+  inline void clear_target_battle_tag();
+  static const int kTargetBattleTagFieldNumber = 8;
+  inline const ::std::string& target_battle_tag() const;
+  inline void set_target_battle_tag(const ::std::string& value);
+  inline void set_target_battle_tag(const char* value);
+  inline void set_target_battle_tag(const char* value, size_t size);
+  inline ::std::string* mutable_target_battle_tag();
+  inline ::std::string* release_target_battle_tag();
+  inline void set_allocated_target_battle_tag(::std::string* target_battle_tag);
+
+  // optional .bgs.protocol.ProcessId peer = 9;
+  inline bool has_peer() const;
+  inline void clear_peer();
+  static const int kPeerFieldNumber = 9;
+  inline const ::bgs::protocol::ProcessId& peer() const;
+  inline ::bgs::protocol::ProcessId* mutable_peer();
+  inline ::bgs::protocol::ProcessId* release_peer();
+  inline void set_allocated_peer(::bgs::protocol::ProcessId* peer);
+
+  // optional .bgs.protocol.account.v1.Identity forwarding_identity = 10;
+  inline bool has_forwarding_identity() const;
+  inline void clear_forwarding_identity();
+  static const int kForwardingIdentityFieldNumber = 10;
+  inline const ::bgs::protocol::account::v1::Identity& forwarding_identity() const;
+  inline ::bgs::protocol::account::v1::Identity* mutable_forwarding_identity();
+  inline ::bgs::protocol::account::v1::Identity* release_forwarding_identity();
+  inline void set_allocated_forwarding_identity(::bgs::protocol::account::v1::Identity* forwarding_identity);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.notification.v1.Notification)
+ private:
+  inline void set_has_sender_id();
+  inline void clear_has_sender_id();
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_sender_account_id();
+  inline void clear_has_sender_account_id();
+  inline void set_has_target_account_id();
+  inline void clear_has_target_account_id();
+  inline void set_has_sender_battle_tag();
+  inline void clear_has_sender_battle_tag();
+  inline void set_has_target_battle_tag();
+  inline void clear_has_target_battle_tag();
+  inline void set_has_peer();
+  inline void clear_has_peer();
+  inline void set_has_forwarding_identity();
+  inline void clear_has_forwarding_identity();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* sender_id_;
+  ::bgs::protocol::EntityId* target_id_;
+  ::std::string* type_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
+  ::bgs::protocol::EntityId* sender_account_id_;
+  ::bgs::protocol::EntityId* target_account_id_;
+  ::std::string* sender_battle_tag_;
+  ::std::string* target_battle_tag_;
+  ::bgs::protocol::ProcessId* peer_;
+  ::bgs::protocol::account::v1::Identity* forwarding_identity_;
+  friend void TC_SHARED_API protobuf_AddDesc_notification_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_notification_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_notification_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Notification* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// Target
+
+// optional .bgs.protocol.account.v1.Identity identity = 1;
+inline bool Target::has_identity() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Target::set_has_identity() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Target::clear_has_identity() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Target::clear_identity() {
+  if (identity_ != NULL) identity_->::bgs::protocol::account::v1::Identity::Clear();
+  clear_has_identity();
+}
+inline const ::bgs::protocol::account::v1::Identity& Target::identity() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Target.identity)
+  return identity_ != NULL ? *identity_ : *default_instance_->identity_;
+}
+inline ::bgs::protocol::account::v1::Identity* Target::mutable_identity() {
+  set_has_identity();
+  if (identity_ == NULL) identity_ = new ::bgs::protocol::account::v1::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Target.identity)
+  return identity_;
+}
+inline ::bgs::protocol::account::v1::Identity* Target::release_identity() {
+  clear_has_identity();
+  ::bgs::protocol::account::v1::Identity* temp = identity_;
+  identity_ = NULL;
+  return temp;
+}
+inline void Target::set_allocated_identity(::bgs::protocol::account::v1::Identity* identity) {
+  delete identity_;
+  identity_ = identity;
+  if (identity) {
+    set_has_identity();
+  } else {
+    clear_has_identity();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Target.identity)
+}
+
+// optional string type = 2;
+inline bool Target::has_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Target::set_has_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Target::clear_has_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Target::clear_type() {
+  if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_->clear();
+  }
+  clear_has_type();
+}
+inline const ::std::string& Target::type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Target.type)
+  return *type_;
+}
+inline void Target::set_type(const ::std::string& value) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_ = new ::std::string;
+  }
+  type_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.notification.v1.Target.type)
+}
+inline void Target::set_type(const char* value) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_ = new ::std::string;
+  }
+  type_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.notification.v1.Target.type)
+}
+inline void Target::set_type(const char* value, size_t size) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_ = new ::std::string;
+  }
+  type_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.notification.v1.Target.type)
+}
+inline ::std::string* Target::mutable_type() {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Target.type)
+  return type_;
+}
+inline ::std::string* Target::release_type() {
+  clear_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = type_;
+    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Target::set_allocated_type(::std::string* type) {
+  if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete type_;
+  }
+  if (type) {
+    set_has_type();
+    type_ = type;
+  } else {
+    clear_has_type();
+    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Target.type)
+}
+
+// -------------------------------------------------------------------
+
+// Subscription
+
+// repeated .bgs.protocol.notification.v1.Target target = 1;
+inline int Subscription::target_size() const {
+  return target_.size();
+}
+inline void Subscription::clear_target() {
+  target_.Clear();
+}
+inline const ::bgs::protocol::notification::v1::Target& Subscription::target(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Subscription.target)
+  return target_.Get(index);
+}
+inline ::bgs::protocol::notification::v1::Target* Subscription::mutable_target(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Subscription.target)
+  return target_.Mutable(index);
+}
+inline ::bgs::protocol::notification::v1::Target* Subscription::add_target() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.notification.v1.Subscription.target)
+  return target_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::notification::v1::Target >&
+Subscription::target() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.notification.v1.Subscription.target)
+  return target_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::notification::v1::Target >*
+Subscription::mutable_target() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.notification.v1.Subscription.target)
+  return &target_;
+}
+
+// optional .bgs.protocol.account.v1.Identity subscriber = 2;
+inline bool Subscription::has_subscriber() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Subscription::set_has_subscriber() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Subscription::clear_has_subscriber() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Subscription::clear_subscriber() {
+  if (subscriber_ != NULL) subscriber_->::bgs::protocol::account::v1::Identity::Clear();
+  clear_has_subscriber();
+}
+inline const ::bgs::protocol::account::v1::Identity& Subscription::subscriber() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Subscription.subscriber)
+  return subscriber_ != NULL ? *subscriber_ : *default_instance_->subscriber_;
+}
+inline ::bgs::protocol::account::v1::Identity* Subscription::mutable_subscriber() {
+  set_has_subscriber();
+  if (subscriber_ == NULL) subscriber_ = new ::bgs::protocol::account::v1::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Subscription.subscriber)
+  return subscriber_;
+}
+inline ::bgs::protocol::account::v1::Identity* Subscription::release_subscriber() {
+  clear_has_subscriber();
+  ::bgs::protocol::account::v1::Identity* temp = subscriber_;
+  subscriber_ = NULL;
+  return temp;
+}
+inline void Subscription::set_allocated_subscriber(::bgs::protocol::account::v1::Identity* subscriber) {
+  delete subscriber_;
+  subscriber_ = subscriber;
+  if (subscriber) {
+    set_has_subscriber();
+  } else {
+    clear_has_subscriber();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Subscription.subscriber)
+}
+
+// optional bool delivery_required = 3 [default = false];
+inline bool Subscription::has_delivery_required() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Subscription::set_has_delivery_required() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Subscription::clear_has_delivery_required() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Subscription::clear_delivery_required() {
+  delivery_required_ = false;
+  clear_has_delivery_required();
+}
+inline bool Subscription::delivery_required() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Subscription.delivery_required)
+  return delivery_required_;
+}
+inline void Subscription::set_delivery_required(bool value) {
+  set_has_delivery_required();
+  delivery_required_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.notification.v1.Subscription.delivery_required)
+}
+
+// -------------------------------------------------------------------
+
+// Notification
+
+// optional .bgs.protocol.EntityId sender_id = 1;
+inline bool Notification::has_sender_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Notification::set_has_sender_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Notification::clear_has_sender_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Notification::clear_sender_id() {
+  if (sender_id_ != NULL) sender_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_sender_id();
+}
+inline const ::bgs::protocol::EntityId& Notification::sender_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.sender_id)
+  return sender_id_ != NULL ? *sender_id_ : *default_instance_->sender_id_;
+}
+inline ::bgs::protocol::EntityId* Notification::mutable_sender_id() {
+  set_has_sender_id();
+  if (sender_id_ == NULL) sender_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.sender_id)
+  return sender_id_;
+}
+inline ::bgs::protocol::EntityId* Notification::release_sender_id() {
+  clear_has_sender_id();
+  ::bgs::protocol::EntityId* temp = sender_id_;
+  sender_id_ = NULL;
+  return temp;
+}
+inline void Notification::set_allocated_sender_id(::bgs::protocol::EntityId* sender_id) {
+  delete sender_id_;
+  sender_id_ = sender_id;
+  if (sender_id) {
+    set_has_sender_id();
+  } else {
+    clear_has_sender_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.sender_id)
+}
+
+// required .bgs.protocol.EntityId target_id = 2;
+inline bool Notification::has_target_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Notification::set_has_target_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Notification::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Notification::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::EntityId& Notification::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::EntityId* Notification::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::EntityId* Notification::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::EntityId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void Notification::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.target_id)
+}
+
+// required string type = 3;
+inline bool Notification::has_type() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Notification::set_has_type() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Notification::clear_has_type() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Notification::clear_type() {
+  if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_->clear();
+  }
+  clear_has_type();
+}
+inline const ::std::string& Notification::type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.type)
+  return *type_;
+}
+inline void Notification::set_type(const ::std::string& value) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_ = new ::std::string;
+  }
+  type_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.notification.v1.Notification.type)
+}
+inline void Notification::set_type(const char* value) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_ = new ::std::string;
+  }
+  type_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.notification.v1.Notification.type)
+}
+inline void Notification::set_type(const char* value, size_t size) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_ = new ::std::string;
+  }
+  type_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.notification.v1.Notification.type)
+}
+inline ::std::string* Notification::mutable_type() {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.type)
+  return type_;
+}
+inline ::std::string* Notification::release_type() {
+  clear_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = type_;
+    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Notification::set_allocated_type(::std::string* type) {
+  if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete type_;
+  }
+  if (type) {
+    set_has_type();
+    type_ = type;
+  } else {
+    clear_has_type();
+    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.type)
+}
+
+// repeated .bgs.protocol.Attribute attribute = 4;
+inline int Notification::attribute_size() const {
+  return attribute_.size();
+}
+inline void Notification::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::Attribute& Notification::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::Attribute* Notification::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* Notification::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.notification.v1.Notification.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+Notification::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.notification.v1.Notification.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+Notification::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.notification.v1.Notification.attribute)
+  return &attribute_;
+}
+
+// optional .bgs.protocol.EntityId sender_account_id = 5;
+inline bool Notification::has_sender_account_id() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void Notification::set_has_sender_account_id() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void Notification::clear_has_sender_account_id() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void Notification::clear_sender_account_id() {
+  if (sender_account_id_ != NULL) sender_account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_sender_account_id();
+}
+inline const ::bgs::protocol::EntityId& Notification::sender_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.sender_account_id)
+  return sender_account_id_ != NULL ? *sender_account_id_ : *default_instance_->sender_account_id_;
+}
+inline ::bgs::protocol::EntityId* Notification::mutable_sender_account_id() {
+  set_has_sender_account_id();
+  if (sender_account_id_ == NULL) sender_account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.sender_account_id)
+  return sender_account_id_;
+}
+inline ::bgs::protocol::EntityId* Notification::release_sender_account_id() {
+  clear_has_sender_account_id();
+  ::bgs::protocol::EntityId* temp = sender_account_id_;
+  sender_account_id_ = NULL;
+  return temp;
+}
+inline void Notification::set_allocated_sender_account_id(::bgs::protocol::EntityId* sender_account_id) {
+  delete sender_account_id_;
+  sender_account_id_ = sender_account_id;
+  if (sender_account_id) {
+    set_has_sender_account_id();
+  } else {
+    clear_has_sender_account_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.sender_account_id)
+}
+
+// optional .bgs.protocol.EntityId target_account_id = 6;
+inline bool Notification::has_target_account_id() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void Notification::set_has_target_account_id() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void Notification::clear_has_target_account_id() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void Notification::clear_target_account_id() {
+  if (target_account_id_ != NULL) target_account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_target_account_id();
+}
+inline const ::bgs::protocol::EntityId& Notification::target_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.target_account_id)
+  return target_account_id_ != NULL ? *target_account_id_ : *default_instance_->target_account_id_;
+}
+inline ::bgs::protocol::EntityId* Notification::mutable_target_account_id() {
+  set_has_target_account_id();
+  if (target_account_id_ == NULL) target_account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.target_account_id)
+  return target_account_id_;
+}
+inline ::bgs::protocol::EntityId* Notification::release_target_account_id() {
+  clear_has_target_account_id();
+  ::bgs::protocol::EntityId* temp = target_account_id_;
+  target_account_id_ = NULL;
+  return temp;
+}
+inline void Notification::set_allocated_target_account_id(::bgs::protocol::EntityId* target_account_id) {
+  delete target_account_id_;
+  target_account_id_ = target_account_id;
+  if (target_account_id) {
+    set_has_target_account_id();
+  } else {
+    clear_has_target_account_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.target_account_id)
+}
+
+// optional string sender_battle_tag = 7;
+inline bool Notification::has_sender_battle_tag() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void Notification::set_has_sender_battle_tag() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void Notification::clear_has_sender_battle_tag() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void Notification::clear_sender_battle_tag() {
+  if (sender_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sender_battle_tag_->clear();
+  }
+  clear_has_sender_battle_tag();
+}
+inline const ::std::string& Notification::sender_battle_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.sender_battle_tag)
+  return *sender_battle_tag_;
+}
+inline void Notification::set_sender_battle_tag(const ::std::string& value) {
+  set_has_sender_battle_tag();
+  if (sender_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sender_battle_tag_ = new ::std::string;
+  }
+  sender_battle_tag_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.notification.v1.Notification.sender_battle_tag)
+}
+inline void Notification::set_sender_battle_tag(const char* value) {
+  set_has_sender_battle_tag();
+  if (sender_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sender_battle_tag_ = new ::std::string;
+  }
+  sender_battle_tag_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.notification.v1.Notification.sender_battle_tag)
+}
+inline void Notification::set_sender_battle_tag(const char* value, size_t size) {
+  set_has_sender_battle_tag();
+  if (sender_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sender_battle_tag_ = new ::std::string;
+  }
+  sender_battle_tag_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.notification.v1.Notification.sender_battle_tag)
+}
+inline ::std::string* Notification::mutable_sender_battle_tag() {
+  set_has_sender_battle_tag();
+  if (sender_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    sender_battle_tag_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.sender_battle_tag)
+  return sender_battle_tag_;
+}
+inline ::std::string* Notification::release_sender_battle_tag() {
+  clear_has_sender_battle_tag();
+  if (sender_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = sender_battle_tag_;
+    sender_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Notification::set_allocated_sender_battle_tag(::std::string* sender_battle_tag) {
+  if (sender_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete sender_battle_tag_;
+  }
+  if (sender_battle_tag) {
+    set_has_sender_battle_tag();
+    sender_battle_tag_ = sender_battle_tag;
+  } else {
+    clear_has_sender_battle_tag();
+    sender_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.sender_battle_tag)
+}
+
+// optional string target_battle_tag = 8;
+inline bool Notification::has_target_battle_tag() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void Notification::set_has_target_battle_tag() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void Notification::clear_has_target_battle_tag() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void Notification::clear_target_battle_tag() {
+  if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_battle_tag_->clear();
+  }
+  clear_has_target_battle_tag();
+}
+inline const ::std::string& Notification::target_battle_tag() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.target_battle_tag)
+  return *target_battle_tag_;
+}
+inline void Notification::set_target_battle_tag(const ::std::string& value) {
+  set_has_target_battle_tag();
+  if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_battle_tag_ = new ::std::string;
+  }
+  target_battle_tag_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.notification.v1.Notification.target_battle_tag)
+}
+inline void Notification::set_target_battle_tag(const char* value) {
+  set_has_target_battle_tag();
+  if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_battle_tag_ = new ::std::string;
+  }
+  target_battle_tag_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.notification.v1.Notification.target_battle_tag)
+}
+inline void Notification::set_target_battle_tag(const char* value, size_t size) {
+  set_has_target_battle_tag();
+  if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_battle_tag_ = new ::std::string;
+  }
+  target_battle_tag_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.notification.v1.Notification.target_battle_tag)
+}
+inline ::std::string* Notification::mutable_target_battle_tag() {
+  set_has_target_battle_tag();
+  if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    target_battle_tag_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.target_battle_tag)
+  return target_battle_tag_;
+}
+inline ::std::string* Notification::release_target_battle_tag() {
+  clear_has_target_battle_tag();
+  if (target_battle_tag_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = target_battle_tag_;
+    target_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Notification::set_allocated_target_battle_tag(::std::string* target_battle_tag) {
+  if (target_battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete target_battle_tag_;
+  }
+  if (target_battle_tag) {
+    set_has_target_battle_tag();
+    target_battle_tag_ = target_battle_tag;
+  } else {
+    clear_has_target_battle_tag();
+    target_battle_tag_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.target_battle_tag)
+}
+
+// optional .bgs.protocol.ProcessId peer = 9;
+inline bool Notification::has_peer() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void Notification::set_has_peer() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void Notification::clear_has_peer() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void Notification::clear_peer() {
+  if (peer_ != NULL) peer_->::bgs::protocol::ProcessId::Clear();
+  clear_has_peer();
+}
+inline const ::bgs::protocol::ProcessId& Notification::peer() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.peer)
+  return peer_ != NULL ? *peer_ : *default_instance_->peer_;
+}
+inline ::bgs::protocol::ProcessId* Notification::mutable_peer() {
+  set_has_peer();
+  if (peer_ == NULL) peer_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.peer)
+  return peer_;
+}
+inline ::bgs::protocol::ProcessId* Notification::release_peer() {
+  clear_has_peer();
+  ::bgs::protocol::ProcessId* temp = peer_;
+  peer_ = NULL;
+  return temp;
+}
+inline void Notification::set_allocated_peer(::bgs::protocol::ProcessId* peer) {
+  delete peer_;
+  peer_ = peer;
+  if (peer) {
+    set_has_peer();
+  } else {
+    clear_has_peer();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.peer)
+}
+
+// optional .bgs.protocol.account.v1.Identity forwarding_identity = 10;
+inline bool Notification::has_forwarding_identity() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void Notification::set_has_forwarding_identity() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void Notification::clear_has_forwarding_identity() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void Notification::clear_forwarding_identity() {
+  if (forwarding_identity_ != NULL) forwarding_identity_->::bgs::protocol::account::v1::Identity::Clear();
+  clear_has_forwarding_identity();
+}
+inline const ::bgs::protocol::account::v1::Identity& Notification::forwarding_identity() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.notification.v1.Notification.forwarding_identity)
+  return forwarding_identity_ != NULL ? *forwarding_identity_ : *default_instance_->forwarding_identity_;
+}
+inline ::bgs::protocol::account::v1::Identity* Notification::mutable_forwarding_identity() {
+  set_has_forwarding_identity();
+  if (forwarding_identity_ == NULL) forwarding_identity_ = new ::bgs::protocol::account::v1::Identity;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.notification.v1.Notification.forwarding_identity)
+  return forwarding_identity_;
+}
+inline ::bgs::protocol::account::v1::Identity* Notification::release_forwarding_identity() {
+  clear_has_forwarding_identity();
+  ::bgs::protocol::account::v1::Identity* temp = forwarding_identity_;
+  forwarding_identity_ = NULL;
+  return temp;
+}
+inline void Notification::set_allocated_forwarding_identity(::bgs::protocol::account::v1::Identity* forwarding_identity) {
+  delete forwarding_identity_;
+  forwarding_identity_ = forwarding_identity;
+  if (forwarding_identity) {
+    set_has_forwarding_identity();
+  } else {
+    clear_has_forwarding_identity();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.notification.v1.Notification.forwarding_identity)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace notification
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_notification_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/presence_service.pb.cc b/src/server/proto/Client/presence_service.pb.cc
new file mode 100644
index 00000000000..3d2cc3f8437
--- /dev/null
+++ b/src/server/proto/Client/presence_service.pb.cc
@@ -0,0 +1,2651 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: presence_service.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "presence_service.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+#include "BattlenetRpcErrorCodes.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace presence {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* SubscribeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscribeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SubscribeNotificationRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscribeNotificationRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UnsubscribeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UnsubscribeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UpdateRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UpdateRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* QueryRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  QueryRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* QueryResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  QueryResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* OwnershipRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  OwnershipRequest_reflection_ = NULL;
+const ::google::protobuf::ServiceDescriptor* PresenceService_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_presence_5fservice_2eproto() {
+  protobuf_AddDesc_presence_5fservice_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "presence_service.proto");
+  GOOGLE_CHECK(file != NULL);
+  SubscribeRequest_descriptor_ = file->message_type(0);
+  static const int SubscribeRequest_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, entity_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, object_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, flag_public_),
+  };
+  SubscribeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscribeRequest_descriptor_,
+      SubscribeRequest::default_instance_,
+      SubscribeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscribeRequest));
+  SubscribeNotificationRequest_descriptor_ = file->message_type(1);
+  static const int SubscribeNotificationRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotificationRequest, entity_id_),
+  };
+  SubscribeNotificationRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscribeNotificationRequest_descriptor_,
+      SubscribeNotificationRequest::default_instance_,
+      SubscribeNotificationRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotificationRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeNotificationRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscribeNotificationRequest));
+  UnsubscribeRequest_descriptor_ = file->message_type(2);
+  static const int UnsubscribeRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, entity_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, object_id_),
+  };
+  UnsubscribeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UnsubscribeRequest_descriptor_,
+      UnsubscribeRequest::default_instance_,
+      UnsubscribeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UnsubscribeRequest));
+  UpdateRequest_descriptor_ = file->message_type(3);
+  static const int UpdateRequest_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRequest, entity_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRequest, field_operation_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRequest, no_create_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRequest, agent_id_),
+  };
+  UpdateRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UpdateRequest_descriptor_,
+      UpdateRequest::default_instance_,
+      UpdateRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UpdateRequest));
+  QueryRequest_descriptor_ = file->message_type(4);
+  static const int QueryRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryRequest, entity_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryRequest, key_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryRequest, agent_id_),
+  };
+  QueryRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      QueryRequest_descriptor_,
+      QueryRequest::default_instance_,
+      QueryRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(QueryRequest));
+  QueryResponse_descriptor_ = file->message_type(5);
+  static const int QueryResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryResponse, field_),
+  };
+  QueryResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      QueryResponse_descriptor_,
+      QueryResponse::default_instance_,
+      QueryResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(QueryResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(QueryResponse));
+  OwnershipRequest_descriptor_ = file->message_type(6);
+  static const int OwnershipRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OwnershipRequest, entity_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OwnershipRequest, release_ownership_),
+  };
+  OwnershipRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      OwnershipRequest_descriptor_,
+      OwnershipRequest::default_instance_,
+      OwnershipRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OwnershipRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(OwnershipRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(OwnershipRequest));
+  PresenceService_descriptor_ = file->service(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_presence_5fservice_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscribeRequest_descriptor_, &SubscribeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscribeNotificationRequest_descriptor_, &SubscribeNotificationRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UnsubscribeRequest_descriptor_, &UnsubscribeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UpdateRequest_descriptor_, &UpdateRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    QueryRequest_descriptor_, &QueryRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    QueryResponse_descriptor_, &QueryResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    OwnershipRequest_descriptor_, &OwnershipRequest::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_presence_5fservice_2eproto() {
+  delete SubscribeRequest::default_instance_;
+  delete SubscribeRequest_reflection_;
+  delete SubscribeNotificationRequest::default_instance_;
+  delete SubscribeNotificationRequest_reflection_;
+  delete UnsubscribeRequest::default_instance_;
+  delete UnsubscribeRequest_reflection_;
+  delete UpdateRequest::default_instance_;
+  delete UpdateRequest_reflection_;
+  delete QueryRequest::default_instance_;
+  delete QueryRequest_reflection_;
+  delete QueryResponse::default_instance_;
+  delete QueryResponse_reflection_;
+  delete OwnershipRequest::default_instance_;
+  delete OwnershipRequest_reflection_;
+}
+
+void protobuf_AddDesc_presence_5fservice_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::bgs::protocol::presence::v1::protobuf_AddDesc_presence_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\026presence_service.proto\022\030bgs.protocol.p"
+    "resence.v1\032\022entity_types.proto\032\024presence"
+    "_types.proto\032\017rpc_types.proto\"\252\001\n\020Subscr"
+    "ibeRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.proto"
+    "col.EntityId\022)\n\tentity_id\030\002 \002(\0132\026.bgs.pr"
+    "otocol.EntityId\022\021\n\tobject_id\030\003 \002(\004\022\017\n\007pr"
+    "ogram\030\004 \003(\007\022\035\n\013flag_public\030\005 \001(\010:\004trueB\002"
+    "\030\001\"I\n\034SubscribeNotificationRequest\022)\n\ten"
+    "tity_id\030\001 \002(\0132\026.bgs.protocol.EntityId\"|\n"
+    "\022UnsubscribeRequest\022(\n\010agent_id\030\001 \001(\0132\026."
+    "bgs.protocol.EntityId\022)\n\tentity_id\030\002 \002(\013"
+    "2\026.bgs.protocol.EntityId\022\021\n\tobject_id\030\003 "
+    "\001(\004\"\301\001\n\rUpdateRequest\022)\n\tentity_id\030\001 \002(\013"
+    "2\026.bgs.protocol.EntityId\022A\n\017field_operat"
+    "ion\030\002 \003(\0132(.bgs.protocol.presence.v1.Fie"
+    "ldOperation\022\030\n\tno_create\030\003 \001(\010:\005false\022(\n"
+    "\010agent_id\030\004 \001(\0132\026.bgs.protocol.EntityId\""
+    "\224\001\n\014QueryRequest\022)\n\tentity_id\030\001 \002(\0132\026.bg"
+    "s.protocol.EntityId\022/\n\003key\030\002 \003(\0132\".bgs.p"
+    "rotocol.presence.v1.FieldKey\022(\n\010agent_id"
+    "\030\003 \001(\0132\026.bgs.protocol.EntityId\"\?\n\rQueryR"
+    "esponse\022.\n\005field\030\002 \003(\0132\037.bgs.protocol.pr"
+    "esence.v1.Field\"_\n\020OwnershipRequest\022)\n\te"
+    "ntity_id\030\001 \002(\0132\026.bgs.protocol.EntityId\022 "
+    "\n\021release_ownership\030\002 \001(\010:\005false2\333\004\n\017Pre"
+    "senceService\022S\n\tSubscribe\022*.bgs.protocol"
+    ".presence.v1.SubscribeRequest\032\024.bgs.prot"
+    "ocol.NoData\"\004\200\265\030\001\022W\n\013Unsubscribe\022,.bgs.p"
+    "rotocol.presence.v1.UnsubscribeRequest\032\024"
+    ".bgs.protocol.NoData\"\004\200\265\030\002\022M\n\006Update\022\'.b"
+    "gs.protocol.presence.v1.UpdateRequest\032\024."
+    "bgs.protocol.NoData\"\004\200\265\030\003\022^\n\005Query\022&.bgs"
+    ".protocol.presence.v1.QueryRequest\032\'.bgs"
+    ".protocol.presence.v1.QueryResponse\"\004\200\265\030"
+    "\004\022S\n\tOwnership\022*.bgs.protocol.presence.v"
+    "1.OwnershipRequest\032\024.bgs.protocol.NoData"
+    "\"\004\200\265\030\005\022k\n\025SubscribeNotification\0226.bgs.pr"
+    "otocol.presence.v1.SubscribeNotification"
+    "Request\032\024.bgs.protocol.NoData\"\004\200\265\030\007\032)\312>&"
+    "bnet.protocol.presence.PresenceServiceB\005"
+    "H\001\200\001\000", 1605);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "presence_service.proto", &protobuf_RegisterTypes);
+  SubscribeRequest::default_instance_ = new SubscribeRequest();
+  SubscribeNotificationRequest::default_instance_ = new SubscribeNotificationRequest();
+  UnsubscribeRequest::default_instance_ = new UnsubscribeRequest();
+  UpdateRequest::default_instance_ = new UpdateRequest();
+  QueryRequest::default_instance_ = new QueryRequest();
+  QueryResponse::default_instance_ = new QueryResponse();
+  OwnershipRequest::default_instance_ = new OwnershipRequest();
+  SubscribeRequest::default_instance_->InitAsDefaultInstance();
+  SubscribeNotificationRequest::default_instance_->InitAsDefaultInstance();
+  UnsubscribeRequest::default_instance_->InitAsDefaultInstance();
+  UpdateRequest::default_instance_->InitAsDefaultInstance();
+  QueryRequest::default_instance_->InitAsDefaultInstance();
+  QueryResponse::default_instance_->InitAsDefaultInstance();
+  OwnershipRequest::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_presence_5fservice_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_presence_5fservice_2eproto {
+  StaticDescriptorInitializer_presence_5fservice_2eproto() {
+    protobuf_AddDesc_presence_5fservice_2eproto();
+  }
+} static_descriptor_initializer_presence_5fservice_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscribeRequest::kAgentIdFieldNumber;
+const int SubscribeRequest::kEntityIdFieldNumber;
+const int SubscribeRequest::kObjectIdFieldNumber;
+const int SubscribeRequest::kProgramFieldNumber;
+const int SubscribeRequest::kFlagPublicFieldNumber;
+#endif  // !_MSC_VER
+
+SubscribeRequest::SubscribeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.SubscribeRequest)
+}
+
+void SubscribeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+SubscribeRequest::SubscribeRequest(const SubscribeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.SubscribeRequest)
+}
+
+void SubscribeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  entity_id_ = NULL;
+  object_id_ = GOOGLE_ULONGLONG(0);
+  flag_public_ = true;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscribeRequest::~SubscribeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.SubscribeRequest)
+  SharedDtor();
+}
+
+void SubscribeRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete entity_id_;
+  }
+}
+
+void SubscribeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscribeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscribeRequest_descriptor_;
+}
+
+const SubscribeRequest& SubscribeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SubscribeRequest* SubscribeRequest::default_instance_ = NULL;
+
+SubscribeRequest* SubscribeRequest::New() const {
+  return new SubscribeRequest;
+}
+
+void SubscribeRequest::Clear() {
+  if (_has_bits_[0 / 32] & 23) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_entity_id()) {
+      if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+    }
+    object_id_ = GOOGLE_ULONGLONG(0);
+    flag_public_ = true;
+  }
+  program_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscribeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.SubscribeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_entity_id;
+        break;
+      }
+
+      // required .bgs.protocol.EntityId entity_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_entity_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_object_id;
+        break;
+      }
+
+      // required uint64 object_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_object_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &object_id_)));
+          set_has_object_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(37)) goto parse_program;
+        break;
+      }
+
+      // repeated fixed32 program = 4;
+      case 4: {
+        if (tag == 37) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 1, 37, input, this->mutable_program())));
+        } else if (tag == 34) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, this->mutable_program())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(37)) goto parse_program;
+        if (input->ExpectTag(40)) goto parse_flag_public;
+        break;
+      }
+
+      // optional bool flag_public = 5 [default = true, deprecated = true];
+      case 5: {
+        if (tag == 40) {
+         parse_flag_public:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &flag_public_)));
+          set_has_flag_public();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.SubscribeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.SubscribeRequest)
+  return false;
+#undef DO_
+}
+
+void SubscribeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.SubscribeRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.EntityId entity_id = 2;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->entity_id(), output);
+  }
+
+  // required uint64 object_id = 3;
+  if (has_object_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->object_id(), output);
+  }
+
+  // repeated fixed32 program = 4;
+  for (int i = 0; i < this->program_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(
+      4, this->program(i), output);
+  }
+
+  // optional bool flag_public = 5 [default = true, deprecated = true];
+  if (has_flag_public()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->flag_public(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.SubscribeRequest)
+}
+
+::google::protobuf::uint8* SubscribeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.SubscribeRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.EntityId entity_id = 2;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->entity_id(), target);
+  }
+
+  // required uint64 object_id = 3;
+  if (has_object_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->object_id(), target);
+  }
+
+  // repeated fixed32 program = 4;
+  for (int i = 0; i < this->program_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteFixed32ToArray(4, this->program(i), target);
+  }
+
+  // optional bool flag_public = 5 [default = true, deprecated = true];
+  if (has_flag_public()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->flag_public(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.SubscribeRequest)
+  return target;
+}
+
+int SubscribeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.EntityId entity_id = 2;
+    if (has_entity_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+    }
+
+    // required uint64 object_id = 3;
+    if (has_object_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->object_id());
+    }
+
+    // optional bool flag_public = 5 [default = true, deprecated = true];
+    if (has_flag_public()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated fixed32 program = 4;
+  {
+    int data_size = 0;
+    data_size = 4 * this->program_size();
+    total_size += 1 * this->program_size() + data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscribeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscribeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscribeRequest::MergeFrom(const SubscribeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  program_.MergeFrom(from.program_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_entity_id()) {
+      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
+    }
+    if (from.has_object_id()) {
+      set_object_id(from.object_id());
+    }
+    if (from.has_flag_public()) {
+      set_flag_public(from.flag_public());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscribeRequest::CopyFrom(const SubscribeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscribeRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000006) != 0x00000006) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_entity_id()) {
+    if (!this->entity_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SubscribeRequest::Swap(SubscribeRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(entity_id_, other->entity_id_);
+    std::swap(object_id_, other->object_id_);
+    program_.Swap(&other->program_);
+    std::swap(flag_public_, other->flag_public_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscribeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscribeRequest_descriptor_;
+  metadata.reflection = SubscribeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscribeNotificationRequest::kEntityIdFieldNumber;
+#endif  // !_MSC_VER
+
+SubscribeNotificationRequest::SubscribeNotificationRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.SubscribeNotificationRequest)
+}
+
+void SubscribeNotificationRequest::InitAsDefaultInstance() {
+  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+SubscribeNotificationRequest::SubscribeNotificationRequest(const SubscribeNotificationRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.SubscribeNotificationRequest)
+}
+
+void SubscribeNotificationRequest::SharedCtor() {
+  _cached_size_ = 0;
+  entity_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscribeNotificationRequest::~SubscribeNotificationRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.SubscribeNotificationRequest)
+  SharedDtor();
+}
+
+void SubscribeNotificationRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete entity_id_;
+  }
+}
+
+void SubscribeNotificationRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscribeNotificationRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscribeNotificationRequest_descriptor_;
+}
+
+const SubscribeNotificationRequest& SubscribeNotificationRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SubscribeNotificationRequest* SubscribeNotificationRequest::default_instance_ = NULL;
+
+SubscribeNotificationRequest* SubscribeNotificationRequest::New() const {
+  return new SubscribeNotificationRequest;
+}
+
+void SubscribeNotificationRequest::Clear() {
+  if (has_entity_id()) {
+    if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscribeNotificationRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.SubscribeNotificationRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.EntityId entity_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.SubscribeNotificationRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.SubscribeNotificationRequest)
+  return false;
+#undef DO_
+}
+
+void SubscribeNotificationRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.SubscribeNotificationRequest)
+  // required .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->entity_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.SubscribeNotificationRequest)
+}
+
+::google::protobuf::uint8* SubscribeNotificationRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.SubscribeNotificationRequest)
+  // required .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->entity_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.SubscribeNotificationRequest)
+  return target;
+}
+
+int SubscribeNotificationRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.EntityId entity_id = 1;
+    if (has_entity_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscribeNotificationRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscribeNotificationRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscribeNotificationRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscribeNotificationRequest::MergeFrom(const SubscribeNotificationRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_entity_id()) {
+      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscribeNotificationRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscribeNotificationRequest::CopyFrom(const SubscribeNotificationRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscribeNotificationRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_entity_id()) {
+    if (!this->entity_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SubscribeNotificationRequest::Swap(SubscribeNotificationRequest* other) {
+  if (other != this) {
+    std::swap(entity_id_, other->entity_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscribeNotificationRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscribeNotificationRequest_descriptor_;
+  metadata.reflection = SubscribeNotificationRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UnsubscribeRequest::kAgentIdFieldNumber;
+const int UnsubscribeRequest::kEntityIdFieldNumber;
+const int UnsubscribeRequest::kObjectIdFieldNumber;
+#endif  // !_MSC_VER
+
+UnsubscribeRequest::UnsubscribeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.UnsubscribeRequest)
+}
+
+void UnsubscribeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+UnsubscribeRequest::UnsubscribeRequest(const UnsubscribeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.UnsubscribeRequest)
+}
+
+void UnsubscribeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  entity_id_ = NULL;
+  object_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UnsubscribeRequest::~UnsubscribeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.UnsubscribeRequest)
+  SharedDtor();
+}
+
+void UnsubscribeRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete entity_id_;
+  }
+}
+
+void UnsubscribeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UnsubscribeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UnsubscribeRequest_descriptor_;
+}
+
+const UnsubscribeRequest& UnsubscribeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto();
+  return *default_instance_;
+}
+
+UnsubscribeRequest* UnsubscribeRequest::default_instance_ = NULL;
+
+UnsubscribeRequest* UnsubscribeRequest::New() const {
+  return new UnsubscribeRequest;
+}
+
+void UnsubscribeRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_entity_id()) {
+      if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+    }
+    object_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UnsubscribeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.UnsubscribeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_entity_id;
+        break;
+      }
+
+      // required .bgs.protocol.EntityId entity_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_entity_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_object_id;
+        break;
+      }
+
+      // optional uint64 object_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_object_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &object_id_)));
+          set_has_object_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.UnsubscribeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.UnsubscribeRequest)
+  return false;
+#undef DO_
+}
+
+void UnsubscribeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.UnsubscribeRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.EntityId entity_id = 2;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->entity_id(), output);
+  }
+
+  // optional uint64 object_id = 3;
+  if (has_object_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->object_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.UnsubscribeRequest)
+}
+
+::google::protobuf::uint8* UnsubscribeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.UnsubscribeRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.EntityId entity_id = 2;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->entity_id(), target);
+  }
+
+  // optional uint64 object_id = 3;
+  if (has_object_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->object_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.UnsubscribeRequest)
+  return target;
+}
+
+int UnsubscribeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.EntityId entity_id = 2;
+    if (has_entity_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+    }
+
+    // optional uint64 object_id = 3;
+    if (has_object_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->object_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UnsubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UnsubscribeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UnsubscribeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UnsubscribeRequest::MergeFrom(const UnsubscribeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_entity_id()) {
+      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
+    }
+    if (from.has_object_id()) {
+      set_object_id(from.object_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UnsubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UnsubscribeRequest::CopyFrom(const UnsubscribeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UnsubscribeRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_entity_id()) {
+    if (!this->entity_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UnsubscribeRequest::Swap(UnsubscribeRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(entity_id_, other->entity_id_);
+    std::swap(object_id_, other->object_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UnsubscribeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UnsubscribeRequest_descriptor_;
+  metadata.reflection = UnsubscribeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UpdateRequest::kEntityIdFieldNumber;
+const int UpdateRequest::kFieldOperationFieldNumber;
+const int UpdateRequest::kNoCreateFieldNumber;
+const int UpdateRequest::kAgentIdFieldNumber;
+#endif  // !_MSC_VER
+
+UpdateRequest::UpdateRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.UpdateRequest)
+}
+
+void UpdateRequest::InitAsDefaultInstance() {
+  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+UpdateRequest::UpdateRequest(const UpdateRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.UpdateRequest)
+}
+
+void UpdateRequest::SharedCtor() {
+  _cached_size_ = 0;
+  entity_id_ = NULL;
+  no_create_ = false;
+  agent_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UpdateRequest::~UpdateRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.UpdateRequest)
+  SharedDtor();
+}
+
+void UpdateRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete entity_id_;
+    delete agent_id_;
+  }
+}
+
+void UpdateRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UpdateRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UpdateRequest_descriptor_;
+}
+
+const UpdateRequest& UpdateRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto();
+  return *default_instance_;
+}
+
+UpdateRequest* UpdateRequest::default_instance_ = NULL;
+
+UpdateRequest* UpdateRequest::New() const {
+  return new UpdateRequest;
+}
+
+void UpdateRequest::Clear() {
+  if (_has_bits_[0 / 32] & 13) {
+    if (has_entity_id()) {
+      if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+    }
+    no_create_ = false;
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  field_operation_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UpdateRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.UpdateRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.EntityId entity_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_field_operation;
+        break;
+      }
+
+      // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_field_operation:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_field_operation()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_field_operation;
+        if (input->ExpectTag(24)) goto parse_no_create;
+        break;
+      }
+
+      // optional bool no_create = 3 [default = false];
+      case 3: {
+        if (tag == 24) {
+         parse_no_create:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &no_create_)));
+          set_has_no_create();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_agent_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId agent_id = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_agent_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.UpdateRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.UpdateRequest)
+  return false;
+#undef DO_
+}
+
+void UpdateRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.UpdateRequest)
+  // required .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->entity_id(), output);
+  }
+
+  // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+  for (int i = 0; i < this->field_operation_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->field_operation(i), output);
+  }
+
+  // optional bool no_create = 3 [default = false];
+  if (has_no_create()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->no_create(), output);
+  }
+
+  // optional .bgs.protocol.EntityId agent_id = 4;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->agent_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.UpdateRequest)
+}
+
+::google::protobuf::uint8* UpdateRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.UpdateRequest)
+  // required .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->entity_id(), target);
+  }
+
+  // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+  for (int i = 0; i < this->field_operation_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->field_operation(i), target);
+  }
+
+  // optional bool no_create = 3 [default = false];
+  if (has_no_create()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->no_create(), target);
+  }
+
+  // optional .bgs.protocol.EntityId agent_id = 4;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->agent_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.UpdateRequest)
+  return target;
+}
+
+int UpdateRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.EntityId entity_id = 1;
+    if (has_entity_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+    }
+
+    // optional bool no_create = 3 [default = false];
+    if (has_no_create()) {
+      total_size += 1 + 1;
+    }
+
+    // optional .bgs.protocol.EntityId agent_id = 4;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+  }
+  // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+  total_size += 1 * this->field_operation_size();
+  for (int i = 0; i < this->field_operation_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->field_operation(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UpdateRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UpdateRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UpdateRequest::MergeFrom(const UpdateRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  field_operation_.MergeFrom(from.field_operation_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_entity_id()) {
+      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
+    }
+    if (from.has_no_create()) {
+      set_no_create(from.no_create());
+    }
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UpdateRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UpdateRequest::CopyFrom(const UpdateRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UpdateRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_entity_id()) {
+    if (!this->entity_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->field_operation())) return false;
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UpdateRequest::Swap(UpdateRequest* other) {
+  if (other != this) {
+    std::swap(entity_id_, other->entity_id_);
+    field_operation_.Swap(&other->field_operation_);
+    std::swap(no_create_, other->no_create_);
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UpdateRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UpdateRequest_descriptor_;
+  metadata.reflection = UpdateRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int QueryRequest::kEntityIdFieldNumber;
+const int QueryRequest::kKeyFieldNumber;
+const int QueryRequest::kAgentIdFieldNumber;
+#endif  // !_MSC_VER
+
+QueryRequest::QueryRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.QueryRequest)
+}
+
+void QueryRequest::InitAsDefaultInstance() {
+  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+QueryRequest::QueryRequest(const QueryRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.QueryRequest)
+}
+
+void QueryRequest::SharedCtor() {
+  _cached_size_ = 0;
+  entity_id_ = NULL;
+  agent_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+QueryRequest::~QueryRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.QueryRequest)
+  SharedDtor();
+}
+
+void QueryRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete entity_id_;
+    delete agent_id_;
+  }
+}
+
+void QueryRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* QueryRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return QueryRequest_descriptor_;
+}
+
+const QueryRequest& QueryRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto();
+  return *default_instance_;
+}
+
+QueryRequest* QueryRequest::default_instance_ = NULL;
+
+QueryRequest* QueryRequest::New() const {
+  return new QueryRequest;
+}
+
+void QueryRequest::Clear() {
+  if (_has_bits_[0 / 32] & 5) {
+    if (has_entity_id()) {
+      if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  key_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool QueryRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.QueryRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.EntityId entity_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_key;
+        break;
+      }
+
+      // repeated .bgs.protocol.presence.v1.FieldKey key = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_key:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_key()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_key;
+        if (input->ExpectTag(26)) goto parse_agent_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId agent_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_agent_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.QueryRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.QueryRequest)
+  return false;
+#undef DO_
+}
+
+void QueryRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.QueryRequest)
+  // required .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->entity_id(), output);
+  }
+
+  // repeated .bgs.protocol.presence.v1.FieldKey key = 2;
+  for (int i = 0; i < this->key_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->key(i), output);
+  }
+
+  // optional .bgs.protocol.EntityId agent_id = 3;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->agent_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.QueryRequest)
+}
+
+::google::protobuf::uint8* QueryRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.QueryRequest)
+  // required .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->entity_id(), target);
+  }
+
+  // repeated .bgs.protocol.presence.v1.FieldKey key = 2;
+  for (int i = 0; i < this->key_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->key(i), target);
+  }
+
+  // optional .bgs.protocol.EntityId agent_id = 3;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->agent_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.QueryRequest)
+  return target;
+}
+
+int QueryRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.EntityId entity_id = 1;
+    if (has_entity_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+    }
+
+    // optional .bgs.protocol.EntityId agent_id = 3;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+  }
+  // repeated .bgs.protocol.presence.v1.FieldKey key = 2;
+  total_size += 1 * this->key_size();
+  for (int i = 0; i < this->key_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->key(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void QueryRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const QueryRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const QueryRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void QueryRequest::MergeFrom(const QueryRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  key_.MergeFrom(from.key_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_entity_id()) {
+      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
+    }
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void QueryRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void QueryRequest::CopyFrom(const QueryRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool QueryRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_entity_id()) {
+    if (!this->entity_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->key())) return false;
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void QueryRequest::Swap(QueryRequest* other) {
+  if (other != this) {
+    std::swap(entity_id_, other->entity_id_);
+    key_.Swap(&other->key_);
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata QueryRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = QueryRequest_descriptor_;
+  metadata.reflection = QueryRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int QueryResponse::kFieldFieldNumber;
+#endif  // !_MSC_VER
+
+QueryResponse::QueryResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.QueryResponse)
+}
+
+void QueryResponse::InitAsDefaultInstance() {
+}
+
+QueryResponse::QueryResponse(const QueryResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.QueryResponse)
+}
+
+void QueryResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+QueryResponse::~QueryResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.QueryResponse)
+  SharedDtor();
+}
+
+void QueryResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void QueryResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* QueryResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return QueryResponse_descriptor_;
+}
+
+const QueryResponse& QueryResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto();
+  return *default_instance_;
+}
+
+QueryResponse* QueryResponse::default_instance_ = NULL;
+
+QueryResponse* QueryResponse::New() const {
+  return new QueryResponse;
+}
+
+void QueryResponse::Clear() {
+  field_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool QueryResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.QueryResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.presence.v1.Field field = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_field:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_field()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_field;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.QueryResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.QueryResponse)
+  return false;
+#undef DO_
+}
+
+void QueryResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.QueryResponse)
+  // repeated .bgs.protocol.presence.v1.Field field = 2;
+  for (int i = 0; i < this->field_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->field(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.QueryResponse)
+}
+
+::google::protobuf::uint8* QueryResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.QueryResponse)
+  // repeated .bgs.protocol.presence.v1.Field field = 2;
+  for (int i = 0; i < this->field_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->field(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.QueryResponse)
+  return target;
+}
+
+int QueryResponse::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.presence.v1.Field field = 2;
+  total_size += 1 * this->field_size();
+  for (int i = 0; i < this->field_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->field(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void QueryResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const QueryResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const QueryResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void QueryResponse::MergeFrom(const QueryResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  field_.MergeFrom(from.field_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void QueryResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void QueryResponse::CopyFrom(const QueryResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool QueryResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->field())) return false;
+  return true;
+}
+
+void QueryResponse::Swap(QueryResponse* other) {
+  if (other != this) {
+    field_.Swap(&other->field_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata QueryResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = QueryResponse_descriptor_;
+  metadata.reflection = QueryResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int OwnershipRequest::kEntityIdFieldNumber;
+const int OwnershipRequest::kReleaseOwnershipFieldNumber;
+#endif  // !_MSC_VER
+
+OwnershipRequest::OwnershipRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.OwnershipRequest)
+}
+
+void OwnershipRequest::InitAsDefaultInstance() {
+  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+OwnershipRequest::OwnershipRequest(const OwnershipRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.OwnershipRequest)
+}
+
+void OwnershipRequest::SharedCtor() {
+  _cached_size_ = 0;
+  entity_id_ = NULL;
+  release_ownership_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+OwnershipRequest::~OwnershipRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.OwnershipRequest)
+  SharedDtor();
+}
+
+void OwnershipRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete entity_id_;
+  }
+}
+
+void OwnershipRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* OwnershipRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return OwnershipRequest_descriptor_;
+}
+
+const OwnershipRequest& OwnershipRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5fservice_2eproto();
+  return *default_instance_;
+}
+
+OwnershipRequest* OwnershipRequest::default_instance_ = NULL;
+
+OwnershipRequest* OwnershipRequest::New() const {
+  return new OwnershipRequest;
+}
+
+void OwnershipRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_entity_id()) {
+      if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+    }
+    release_ownership_ = false;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool OwnershipRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.OwnershipRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.EntityId entity_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_release_ownership;
+        break;
+      }
+
+      // optional bool release_ownership = 2 [default = false];
+      case 2: {
+        if (tag == 16) {
+         parse_release_ownership:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &release_ownership_)));
+          set_has_release_ownership();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.OwnershipRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.OwnershipRequest)
+  return false;
+#undef DO_
+}
+
+void OwnershipRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.OwnershipRequest)
+  // required .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->entity_id(), output);
+  }
+
+  // optional bool release_ownership = 2 [default = false];
+  if (has_release_ownership()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->release_ownership(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.OwnershipRequest)
+}
+
+::google::protobuf::uint8* OwnershipRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.OwnershipRequest)
+  // required .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->entity_id(), target);
+  }
+
+  // optional bool release_ownership = 2 [default = false];
+  if (has_release_ownership()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->release_ownership(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.OwnershipRequest)
+  return target;
+}
+
+int OwnershipRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.EntityId entity_id = 1;
+    if (has_entity_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+    }
+
+    // optional bool release_ownership = 2 [default = false];
+    if (has_release_ownership()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void OwnershipRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const OwnershipRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const OwnershipRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void OwnershipRequest::MergeFrom(const OwnershipRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_entity_id()) {
+      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
+    }
+    if (from.has_release_ownership()) {
+      set_release_ownership(from.release_ownership());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void OwnershipRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void OwnershipRequest::CopyFrom(const OwnershipRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool OwnershipRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_entity_id()) {
+    if (!this->entity_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void OwnershipRequest::Swap(OwnershipRequest* other) {
+  if (other != this) {
+    std::swap(entity_id_, other->entity_id_);
+    std::swap(release_ownership_, other->release_ownership_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata OwnershipRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = OwnershipRequest_descriptor_;
+  metadata.reflection = OwnershipRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* PresenceService::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return PresenceService_descriptor_;
+}
+
+void PresenceService::Subscribe(::bgs::protocol::presence::v1::SubscribeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceService.Subscribe(bgs.protocol.presence.v1.SubscribeRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void PresenceService::Unsubscribe(::bgs::protocol::presence::v1::UnsubscribeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceService.Unsubscribe(bgs.protocol.presence.v1.UnsubscribeRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 2, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void PresenceService::Update(::bgs::protocol::presence::v1::UpdateRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceService.Update(bgs.protocol.presence.v1.UpdateRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 3, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void PresenceService::Query(::bgs::protocol::presence::v1::QueryRequest const* request, std::function<void(::bgs::protocol::presence::v1::QueryResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceService.Query(bgs.protocol.presence.v1.QueryRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 4, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::presence::v1::QueryResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void PresenceService::Ownership(::bgs::protocol::presence::v1::OwnershipRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceService.Ownership(bgs.protocol.presence.v1.OwnershipRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 5, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void PresenceService::SubscribeNotification(::bgs::protocol::presence::v1::SubscribeNotificationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method PresenceService.SubscribeNotification(bgs.protocol.presence.v1.SubscribeNotificationRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 7, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void PresenceService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::presence::v1::SubscribeRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceService.Subscribe server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleSubscribe(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.Subscribe(bgs.protocol.presence.v1.SubscribeRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 1, token, &response);
+      else
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    case 2: {
+      ::bgs::protocol::presence::v1::UnsubscribeRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceService.Unsubscribe server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleUnsubscribe(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.Unsubscribe(bgs.protocol.presence.v1.UnsubscribeRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 2, token, &response);
+      else
+        SendResponse(service_hash_, 2, token, status);
+      break;
+    }
+    case 3: {
+      ::bgs::protocol::presence::v1::UpdateRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceService.Update server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 3, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleUpdate(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.Update(bgs.protocol.presence.v1.UpdateRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 3, token, &response);
+      else
+        SendResponse(service_hash_, 3, token, status);
+      break;
+    }
+    case 4: {
+      ::bgs::protocol::presence::v1::QueryRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceService.Query server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 4, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::presence::v1::QueryResponse response;
+      uint32 status = HandleQuery(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.Query(bgs.protocol.presence.v1.QueryRequest{ %s }) returned bgs.protocol.presence.v1.QueryResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 4, token, &response);
+      else
+        SendResponse(service_hash_, 4, token, status);
+      break;
+    }
+    case 5: {
+      ::bgs::protocol::presence::v1::OwnershipRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceService.Ownership server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 5, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleOwnership(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.Ownership(bgs.protocol.presence.v1.OwnershipRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 5, token, &response);
+      else
+        SendResponse(service_hash_, 5, token, status);
+      break;
+    }
+    case 7: {
+      ::bgs::protocol::presence::v1::SubscribeNotificationRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for PresenceService.SubscribeNotification server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 7, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleSubscribeNotification(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method PresenceService.SubscribeNotification(bgs.protocol.presence.v1.SubscribeNotificationRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 7, token, &response);
+      else
+        SendResponse(service_hash_, 7, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 PresenceService::HandleSubscribe(::bgs::protocol::presence::v1::SubscribeRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceService.Subscribe({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 PresenceService::HandleUnsubscribe(::bgs::protocol::presence::v1::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceService.Unsubscribe({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 PresenceService::HandleUpdate(::bgs::protocol::presence::v1::UpdateRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceService.Update({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 PresenceService::HandleQuery(::bgs::protocol::presence::v1::QueryRequest const* request, ::bgs::protocol::presence::v1::QueryResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceService.Query({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 PresenceService::HandleOwnership(::bgs::protocol::presence::v1::OwnershipRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceService.Ownership({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 PresenceService::HandleSubscribeNotification(::bgs::protocol::presence::v1::SubscribeNotificationRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method PresenceService.SubscribeNotification({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace presence
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/presence_service.pb.h b/src/server/proto/Client/presence_service.pb.h
new file mode 100644
index 00000000000..a9dd7c6678b
--- /dev/null
+++ b/src/server/proto/Client/presence_service.pb.h
@@ -0,0 +1,1499 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: presence_service.proto
+
+#ifndef PROTOBUF_presence_5fservice_2eproto__INCLUDED
+#define PROTOBUF_presence_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 "entity_types.pb.h"
+#include "presence_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 presence {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_presence_5fservice_2eproto();
+void protobuf_AssignDesc_presence_5fservice_2eproto();
+void protobuf_ShutdownFile_presence_5fservice_2eproto();
+
+class SubscribeRequest;
+class SubscribeNotificationRequest;
+class UnsubscribeRequest;
+class UpdateRequest;
+class QueryRequest;
+class QueryResponse;
+class OwnershipRequest;
+
+// ===================================================================
+
+class TC_SHARED_API SubscribeRequest : public ::google::protobuf::Message {
+ public:
+  SubscribeRequest();
+  virtual ~SubscribeRequest();
+
+  SubscribeRequest(const SubscribeRequest& from);
+
+  inline SubscribeRequest& operator=(const SubscribeRequest& 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 SubscribeRequest& default_instance();
+
+  void Swap(SubscribeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscribeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscribeRequest& from);
+  void MergeFrom(const SubscribeRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.EntityId entity_id = 2;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // required uint64 object_id = 3;
+  inline bool has_object_id() const;
+  inline void clear_object_id();
+  static const int kObjectIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 object_id() const;
+  inline void set_object_id(::google::protobuf::uint64 value);
+
+  // repeated fixed32 program = 4;
+  inline int program_size() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 4;
+  inline ::google::protobuf::uint32 program(int index) const;
+  inline void set_program(int index, ::google::protobuf::uint32 value);
+  inline void add_program(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      program() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_program();
+
+  // optional bool flag_public = 5 [default = true, deprecated = true];
+  inline bool has_flag_public() const PROTOBUF_DEPRECATED;
+  inline void clear_flag_public() PROTOBUF_DEPRECATED;
+  static const int kFlagPublicFieldNumber = 5;
+  inline bool flag_public() const PROTOBUF_DEPRECATED;
+  inline void set_flag_public(bool value) PROTOBUF_DEPRECATED;
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.SubscribeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+  inline void set_has_object_id();
+  inline void clear_has_object_id();
+  inline void set_has_flag_public();
+  inline void clear_has_flag_public();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::EntityId* entity_id_;
+  ::google::protobuf::uint64 object_id_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > program_;
+  bool flag_public_;
+  friend void TC_SHARED_API protobuf_AddDesc_presence_5fservice_2eproto();
+  friend void protobuf_AssignDesc_presence_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_presence_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscribeRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API SubscribeNotificationRequest : public ::google::protobuf::Message {
+ public:
+  SubscribeNotificationRequest();
+  virtual ~SubscribeNotificationRequest();
+
+  SubscribeNotificationRequest(const SubscribeNotificationRequest& from);
+
+  inline SubscribeNotificationRequest& operator=(const SubscribeNotificationRequest& 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 SubscribeNotificationRequest& default_instance();
+
+  void Swap(SubscribeNotificationRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscribeNotificationRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscribeNotificationRequest& from);
+  void MergeFrom(const SubscribeNotificationRequest& 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 entity_id = 1;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.SubscribeNotificationRequest)
+ private:
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* entity_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_presence_5fservice_2eproto();
+  friend void protobuf_AssignDesc_presence_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_presence_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscribeNotificationRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API UnsubscribeRequest : public ::google::protobuf::Message {
+ public:
+  UnsubscribeRequest();
+  virtual ~UnsubscribeRequest();
+
+  UnsubscribeRequest(const UnsubscribeRequest& from);
+
+  inline UnsubscribeRequest& operator=(const UnsubscribeRequest& 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 UnsubscribeRequest& default_instance();
+
+  void Swap(UnsubscribeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UnsubscribeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UnsubscribeRequest& from);
+  void MergeFrom(const UnsubscribeRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.EntityId entity_id = 2;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // optional uint64 object_id = 3;
+  inline bool has_object_id() const;
+  inline void clear_object_id();
+  static const int kObjectIdFieldNumber = 3;
+  inline ::google::protobuf::uint64 object_id() const;
+  inline void set_object_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.UnsubscribeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+  inline void set_has_object_id();
+  inline void clear_has_object_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::EntityId* entity_id_;
+  ::google::protobuf::uint64 object_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_presence_5fservice_2eproto();
+  friend void protobuf_AssignDesc_presence_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_presence_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static UnsubscribeRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API UpdateRequest : public ::google::protobuf::Message {
+ public:
+  UpdateRequest();
+  virtual ~UpdateRequest();
+
+  UpdateRequest(const UpdateRequest& from);
+
+  inline UpdateRequest& operator=(const UpdateRequest& 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 UpdateRequest& default_instance();
+
+  void Swap(UpdateRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UpdateRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UpdateRequest& from);
+  void MergeFrom(const UpdateRequest& 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 entity_id = 1;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+  inline int field_operation_size() const;
+  inline void clear_field_operation();
+  static const int kFieldOperationFieldNumber = 2;
+  inline const ::bgs::protocol::presence::v1::FieldOperation& field_operation(int index) const;
+  inline ::bgs::protocol::presence::v1::FieldOperation* mutable_field_operation(int index);
+  inline ::bgs::protocol::presence::v1::FieldOperation* add_field_operation();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >&
+      field_operation() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >*
+      mutable_field_operation();
+
+  // optional bool no_create = 3 [default = false];
+  inline bool has_no_create() const;
+  inline void clear_no_create();
+  static const int kNoCreateFieldNumber = 3;
+  inline bool no_create() const;
+  inline void set_no_create(bool value);
+
+  // optional .bgs.protocol.EntityId agent_id = 4;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 4;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.UpdateRequest)
+ private:
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+  inline void set_has_no_create();
+  inline void clear_has_no_create();
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* entity_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation > field_operation_;
+  ::bgs::protocol::EntityId* agent_id_;
+  bool no_create_;
+  friend void TC_SHARED_API protobuf_AddDesc_presence_5fservice_2eproto();
+  friend void protobuf_AssignDesc_presence_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_presence_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static UpdateRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API QueryRequest : public ::google::protobuf::Message {
+ public:
+  QueryRequest();
+  virtual ~QueryRequest();
+
+  QueryRequest(const QueryRequest& from);
+
+  inline QueryRequest& operator=(const QueryRequest& 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 QueryRequest& default_instance();
+
+  void Swap(QueryRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  QueryRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const QueryRequest& from);
+  void MergeFrom(const QueryRequest& 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 entity_id = 1;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // repeated .bgs.protocol.presence.v1.FieldKey key = 2;
+  inline int key_size() const;
+  inline void clear_key();
+  static const int kKeyFieldNumber = 2;
+  inline const ::bgs::protocol::presence::v1::FieldKey& key(int index) const;
+  inline ::bgs::protocol::presence::v1::FieldKey* mutable_key(int index);
+  inline ::bgs::protocol::presence::v1::FieldKey* add_key();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey >&
+      key() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey >*
+      mutable_key();
+
+  // optional .bgs.protocol.EntityId agent_id = 3;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 3;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.QueryRequest)
+ private:
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* entity_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey > key_;
+  ::bgs::protocol::EntityId* agent_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_presence_5fservice_2eproto();
+  friend void protobuf_AssignDesc_presence_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_presence_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static QueryRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API QueryResponse : public ::google::protobuf::Message {
+ public:
+  QueryResponse();
+  virtual ~QueryResponse();
+
+  QueryResponse(const QueryResponse& from);
+
+  inline QueryResponse& operator=(const QueryResponse& 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 QueryResponse& default_instance();
+
+  void Swap(QueryResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  QueryResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const QueryResponse& from);
+  void MergeFrom(const QueryResponse& 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.presence.v1.Field field = 2;
+  inline int field_size() const;
+  inline void clear_field();
+  static const int kFieldFieldNumber = 2;
+  inline const ::bgs::protocol::presence::v1::Field& field(int index) const;
+  inline ::bgs::protocol::presence::v1::Field* mutable_field(int index);
+  inline ::bgs::protocol::presence::v1::Field* add_field();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::Field >&
+      field() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::Field >*
+      mutable_field();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.QueryResponse)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::Field > field_;
+  friend void TC_SHARED_API protobuf_AddDesc_presence_5fservice_2eproto();
+  friend void protobuf_AssignDesc_presence_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_presence_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static QueryResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API OwnershipRequest : public ::google::protobuf::Message {
+ public:
+  OwnershipRequest();
+  virtual ~OwnershipRequest();
+
+  OwnershipRequest(const OwnershipRequest& from);
+
+  inline OwnershipRequest& operator=(const OwnershipRequest& 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 OwnershipRequest& default_instance();
+
+  void Swap(OwnershipRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  OwnershipRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const OwnershipRequest& from);
+  void MergeFrom(const OwnershipRequest& 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 entity_id = 1;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // optional bool release_ownership = 2 [default = false];
+  inline bool has_release_ownership() const;
+  inline void clear_release_ownership();
+  static const int kReleaseOwnershipFieldNumber = 2;
+  inline bool release_ownership() const;
+  inline void set_release_ownership(bool value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.OwnershipRequest)
+ private:
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+  inline void set_has_release_ownership();
+  inline void clear_has_release_ownership();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* entity_id_;
+  bool release_ownership_;
+  friend void TC_SHARED_API protobuf_AddDesc_presence_5fservice_2eproto();
+  friend void protobuf_AssignDesc_presence_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_presence_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static OwnershipRequest* default_instance_;
+};
+// ===================================================================
+
+class TC_SHARED_API PresenceService : public ServiceBase
+{
+ public:
+
+  template<typename HashSelector>
+  explicit PresenceService(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  typedef std::integral_constant<uint32, 0xFA0796FFu> OriginalHash;
+  typedef std::integral_constant<uint32, 0xD8F94B3Bu> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void Subscribe(::bgs::protocol::presence::v1::SubscribeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void Unsubscribe(::bgs::protocol::presence::v1::UnsubscribeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void Update(::bgs::protocol::presence::v1::UpdateRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void Query(::bgs::protocol::presence::v1::QueryRequest const* request, std::function<void(::bgs::protocol::presence::v1::QueryResponse const*)> responseCallback);
+  void Ownership(::bgs::protocol::presence::v1::OwnershipRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void SubscribeNotification(::bgs::protocol::presence::v1::SubscribeNotificationRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleSubscribe(::bgs::protocol::presence::v1::SubscribeRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleUnsubscribe(::bgs::protocol::presence::v1::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleUpdate(::bgs::protocol::presence::v1::UpdateRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleQuery(::bgs::protocol::presence::v1::QueryRequest const* request, ::bgs::protocol::presence::v1::QueryResponse* response);
+  virtual uint32 HandleOwnership(::bgs::protocol::presence::v1::OwnershipRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleSubscribeNotification(::bgs::protocol::presence::v1::SubscribeNotificationRequest const* request, ::bgs::protocol::NoData* response);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(PresenceService);
+};
+
+// ===================================================================
+
+
+// ===================================================================
+
+// SubscribeRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool SubscribeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SubscribeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SubscribeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SubscribeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& SubscribeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* SubscribeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.SubscribeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* SubscribeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SubscribeRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.SubscribeRequest.agent_id)
+}
+
+// required .bgs.protocol.EntityId entity_id = 2;
+inline bool SubscribeRequest::has_entity_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SubscribeRequest::set_has_entity_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SubscribeRequest::clear_has_entity_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SubscribeRequest::clear_entity_id() {
+  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id();
+}
+inline const ::bgs::protocol::EntityId& SubscribeRequest::entity_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeRequest.entity_id)
+  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
+}
+inline ::bgs::protocol::EntityId* SubscribeRequest::mutable_entity_id() {
+  set_has_entity_id();
+  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.SubscribeRequest.entity_id)
+  return entity_id_;
+}
+inline ::bgs::protocol::EntityId* SubscribeRequest::release_entity_id() {
+  clear_has_entity_id();
+  ::bgs::protocol::EntityId* temp = entity_id_;
+  entity_id_ = NULL;
+  return temp;
+}
+inline void SubscribeRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
+  delete entity_id_;
+  entity_id_ = entity_id;
+  if (entity_id) {
+    set_has_entity_id();
+  } else {
+    clear_has_entity_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.SubscribeRequest.entity_id)
+}
+
+// required uint64 object_id = 3;
+inline bool SubscribeRequest::has_object_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void SubscribeRequest::set_has_object_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void SubscribeRequest::clear_has_object_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void SubscribeRequest::clear_object_id() {
+  object_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_object_id();
+}
+inline ::google::protobuf::uint64 SubscribeRequest::object_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeRequest.object_id)
+  return object_id_;
+}
+inline void SubscribeRequest::set_object_id(::google::protobuf::uint64 value) {
+  set_has_object_id();
+  object_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.SubscribeRequest.object_id)
+}
+
+// repeated fixed32 program = 4;
+inline int SubscribeRequest::program_size() const {
+  return program_.size();
+}
+inline void SubscribeRequest::clear_program() {
+  program_.Clear();
+}
+inline ::google::protobuf::uint32 SubscribeRequest::program(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeRequest.program)
+  return program_.Get(index);
+}
+inline void SubscribeRequest::set_program(int index, ::google::protobuf::uint32 value) {
+  program_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.SubscribeRequest.program)
+}
+inline void SubscribeRequest::add_program(::google::protobuf::uint32 value) {
+  program_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.SubscribeRequest.program)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+SubscribeRequest::program() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.SubscribeRequest.program)
+  return program_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+SubscribeRequest::mutable_program() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.SubscribeRequest.program)
+  return &program_;
+}
+
+// optional bool flag_public = 5 [default = true, deprecated = true];
+inline bool SubscribeRequest::has_flag_public() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void SubscribeRequest::set_has_flag_public() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void SubscribeRequest::clear_has_flag_public() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void SubscribeRequest::clear_flag_public() {
+  flag_public_ = true;
+  clear_has_flag_public();
+}
+inline bool SubscribeRequest::flag_public() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeRequest.flag_public)
+  return flag_public_;
+}
+inline void SubscribeRequest::set_flag_public(bool value) {
+  set_has_flag_public();
+  flag_public_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.SubscribeRequest.flag_public)
+}
+
+// -------------------------------------------------------------------
+
+// SubscribeNotificationRequest
+
+// required .bgs.protocol.EntityId entity_id = 1;
+inline bool SubscribeNotificationRequest::has_entity_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SubscribeNotificationRequest::set_has_entity_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SubscribeNotificationRequest::clear_has_entity_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SubscribeNotificationRequest::clear_entity_id() {
+  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id();
+}
+inline const ::bgs::protocol::EntityId& SubscribeNotificationRequest::entity_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.SubscribeNotificationRequest.entity_id)
+  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
+}
+inline ::bgs::protocol::EntityId* SubscribeNotificationRequest::mutable_entity_id() {
+  set_has_entity_id();
+  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.SubscribeNotificationRequest.entity_id)
+  return entity_id_;
+}
+inline ::bgs::protocol::EntityId* SubscribeNotificationRequest::release_entity_id() {
+  clear_has_entity_id();
+  ::bgs::protocol::EntityId* temp = entity_id_;
+  entity_id_ = NULL;
+  return temp;
+}
+inline void SubscribeNotificationRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
+  delete entity_id_;
+  entity_id_ = entity_id;
+  if (entity_id) {
+    set_has_entity_id();
+  } else {
+    clear_has_entity_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.SubscribeNotificationRequest.entity_id)
+}
+
+// -------------------------------------------------------------------
+
+// UnsubscribeRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool UnsubscribeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UnsubscribeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UnsubscribeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UnsubscribeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& UnsubscribeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.UnsubscribeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* UnsubscribeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.UnsubscribeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* UnsubscribeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UnsubscribeRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.UnsubscribeRequest.agent_id)
+}
+
+// required .bgs.protocol.EntityId entity_id = 2;
+inline bool UnsubscribeRequest::has_entity_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UnsubscribeRequest::set_has_entity_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UnsubscribeRequest::clear_has_entity_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UnsubscribeRequest::clear_entity_id() {
+  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id();
+}
+inline const ::bgs::protocol::EntityId& UnsubscribeRequest::entity_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.UnsubscribeRequest.entity_id)
+  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
+}
+inline ::bgs::protocol::EntityId* UnsubscribeRequest::mutable_entity_id() {
+  set_has_entity_id();
+  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.UnsubscribeRequest.entity_id)
+  return entity_id_;
+}
+inline ::bgs::protocol::EntityId* UnsubscribeRequest::release_entity_id() {
+  clear_has_entity_id();
+  ::bgs::protocol::EntityId* temp = entity_id_;
+  entity_id_ = NULL;
+  return temp;
+}
+inline void UnsubscribeRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
+  delete entity_id_;
+  entity_id_ = entity_id;
+  if (entity_id) {
+    set_has_entity_id();
+  } else {
+    clear_has_entity_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.UnsubscribeRequest.entity_id)
+}
+
+// optional uint64 object_id = 3;
+inline bool UnsubscribeRequest::has_object_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void UnsubscribeRequest::set_has_object_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void UnsubscribeRequest::clear_has_object_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void UnsubscribeRequest::clear_object_id() {
+  object_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_object_id();
+}
+inline ::google::protobuf::uint64 UnsubscribeRequest::object_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.UnsubscribeRequest.object_id)
+  return object_id_;
+}
+inline void UnsubscribeRequest::set_object_id(::google::protobuf::uint64 value) {
+  set_has_object_id();
+  object_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.UnsubscribeRequest.object_id)
+}
+
+// -------------------------------------------------------------------
+
+// UpdateRequest
+
+// required .bgs.protocol.EntityId entity_id = 1;
+inline bool UpdateRequest::has_entity_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UpdateRequest::set_has_entity_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UpdateRequest::clear_has_entity_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UpdateRequest::clear_entity_id() {
+  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id();
+}
+inline const ::bgs::protocol::EntityId& UpdateRequest::entity_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.UpdateRequest.entity_id)
+  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateRequest::mutable_entity_id() {
+  set_has_entity_id();
+  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.UpdateRequest.entity_id)
+  return entity_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateRequest::release_entity_id() {
+  clear_has_entity_id();
+  ::bgs::protocol::EntityId* temp = entity_id_;
+  entity_id_ = NULL;
+  return temp;
+}
+inline void UpdateRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
+  delete entity_id_;
+  entity_id_ = entity_id;
+  if (entity_id) {
+    set_has_entity_id();
+  } else {
+    clear_has_entity_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.UpdateRequest.entity_id)
+}
+
+// repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+inline int UpdateRequest::field_operation_size() const {
+  return field_operation_.size();
+}
+inline void UpdateRequest::clear_field_operation() {
+  field_operation_.Clear();
+}
+inline const ::bgs::protocol::presence::v1::FieldOperation& UpdateRequest::field_operation(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.UpdateRequest.field_operation)
+  return field_operation_.Get(index);
+}
+inline ::bgs::protocol::presence::v1::FieldOperation* UpdateRequest::mutable_field_operation(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.UpdateRequest.field_operation)
+  return field_operation_.Mutable(index);
+}
+inline ::bgs::protocol::presence::v1::FieldOperation* UpdateRequest::add_field_operation() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.UpdateRequest.field_operation)
+  return field_operation_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >&
+UpdateRequest::field_operation() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.UpdateRequest.field_operation)
+  return field_operation_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >*
+UpdateRequest::mutable_field_operation() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.UpdateRequest.field_operation)
+  return &field_operation_;
+}
+
+// optional bool no_create = 3 [default = false];
+inline bool UpdateRequest::has_no_create() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void UpdateRequest::set_has_no_create() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void UpdateRequest::clear_has_no_create() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void UpdateRequest::clear_no_create() {
+  no_create_ = false;
+  clear_has_no_create();
+}
+inline bool UpdateRequest::no_create() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.UpdateRequest.no_create)
+  return no_create_;
+}
+inline void UpdateRequest::set_no_create(bool value) {
+  set_has_no_create();
+  no_create_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.UpdateRequest.no_create)
+}
+
+// optional .bgs.protocol.EntityId agent_id = 4;
+inline bool UpdateRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void UpdateRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void UpdateRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void UpdateRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& UpdateRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.UpdateRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.UpdateRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* UpdateRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UpdateRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.UpdateRequest.agent_id)
+}
+
+// -------------------------------------------------------------------
+
+// QueryRequest
+
+// required .bgs.protocol.EntityId entity_id = 1;
+inline bool QueryRequest::has_entity_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void QueryRequest::set_has_entity_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void QueryRequest::clear_has_entity_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void QueryRequest::clear_entity_id() {
+  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id();
+}
+inline const ::bgs::protocol::EntityId& QueryRequest::entity_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.QueryRequest.entity_id)
+  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
+}
+inline ::bgs::protocol::EntityId* QueryRequest::mutable_entity_id() {
+  set_has_entity_id();
+  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.QueryRequest.entity_id)
+  return entity_id_;
+}
+inline ::bgs::protocol::EntityId* QueryRequest::release_entity_id() {
+  clear_has_entity_id();
+  ::bgs::protocol::EntityId* temp = entity_id_;
+  entity_id_ = NULL;
+  return temp;
+}
+inline void QueryRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
+  delete entity_id_;
+  entity_id_ = entity_id;
+  if (entity_id) {
+    set_has_entity_id();
+  } else {
+    clear_has_entity_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.QueryRequest.entity_id)
+}
+
+// repeated .bgs.protocol.presence.v1.FieldKey key = 2;
+inline int QueryRequest::key_size() const {
+  return key_.size();
+}
+inline void QueryRequest::clear_key() {
+  key_.Clear();
+}
+inline const ::bgs::protocol::presence::v1::FieldKey& QueryRequest::key(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.QueryRequest.key)
+  return key_.Get(index);
+}
+inline ::bgs::protocol::presence::v1::FieldKey* QueryRequest::mutable_key(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.QueryRequest.key)
+  return key_.Mutable(index);
+}
+inline ::bgs::protocol::presence::v1::FieldKey* QueryRequest::add_key() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.QueryRequest.key)
+  return key_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey >&
+QueryRequest::key() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.QueryRequest.key)
+  return key_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldKey >*
+QueryRequest::mutable_key() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.QueryRequest.key)
+  return &key_;
+}
+
+// optional .bgs.protocol.EntityId agent_id = 3;
+inline bool QueryRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void QueryRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void QueryRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void QueryRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& QueryRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.QueryRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* QueryRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.QueryRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* QueryRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void QueryRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.QueryRequest.agent_id)
+}
+
+// -------------------------------------------------------------------
+
+// QueryResponse
+
+// repeated .bgs.protocol.presence.v1.Field field = 2;
+inline int QueryResponse::field_size() const {
+  return field_.size();
+}
+inline void QueryResponse::clear_field() {
+  field_.Clear();
+}
+inline const ::bgs::protocol::presence::v1::Field& QueryResponse::field(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.QueryResponse.field)
+  return field_.Get(index);
+}
+inline ::bgs::protocol::presence::v1::Field* QueryResponse::mutable_field(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.QueryResponse.field)
+  return field_.Mutable(index);
+}
+inline ::bgs::protocol::presence::v1::Field* QueryResponse::add_field() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.QueryResponse.field)
+  return field_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::Field >&
+QueryResponse::field() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.QueryResponse.field)
+  return field_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::Field >*
+QueryResponse::mutable_field() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.QueryResponse.field)
+  return &field_;
+}
+
+// -------------------------------------------------------------------
+
+// OwnershipRequest
+
+// required .bgs.protocol.EntityId entity_id = 1;
+inline bool OwnershipRequest::has_entity_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void OwnershipRequest::set_has_entity_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void OwnershipRequest::clear_has_entity_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void OwnershipRequest::clear_entity_id() {
+  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id();
+}
+inline const ::bgs::protocol::EntityId& OwnershipRequest::entity_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.OwnershipRequest.entity_id)
+  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
+}
+inline ::bgs::protocol::EntityId* OwnershipRequest::mutable_entity_id() {
+  set_has_entity_id();
+  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.OwnershipRequest.entity_id)
+  return entity_id_;
+}
+inline ::bgs::protocol::EntityId* OwnershipRequest::release_entity_id() {
+  clear_has_entity_id();
+  ::bgs::protocol::EntityId* temp = entity_id_;
+  entity_id_ = NULL;
+  return temp;
+}
+inline void OwnershipRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
+  delete entity_id_;
+  entity_id_ = entity_id;
+  if (entity_id) {
+    set_has_entity_id();
+  } else {
+    clear_has_entity_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.OwnershipRequest.entity_id)
+}
+
+// optional bool release_ownership = 2 [default = false];
+inline bool OwnershipRequest::has_release_ownership() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void OwnershipRequest::set_has_release_ownership() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void OwnershipRequest::clear_has_release_ownership() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void OwnershipRequest::clear_release_ownership() {
+  release_ownership_ = false;
+  clear_has_release_ownership();
+}
+inline bool OwnershipRequest::release_ownership() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.OwnershipRequest.release_ownership)
+  return release_ownership_;
+}
+inline void OwnershipRequest::set_release_ownership(bool value) {
+  set_has_release_ownership();
+  release_ownership_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.OwnershipRequest.release_ownership)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace presence
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_presence_5fservice_2eproto__INCLUDED
diff --git a/src/server/proto/Client/presence_types.pb.cc b/src/server/proto/Client/presence_types.pb.cc
new file mode 100644
index 00000000000..e57ad02268b
--- /dev/null
+++ b/src/server/proto/Client/presence_types.pb.cc
@@ -0,0 +1,1801 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: presence_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "presence_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace presence {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* RichPresenceLocalizationKey_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RichPresenceLocalizationKey_reflection_ = NULL;
+const ::google::protobuf::Descriptor* FieldKey_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  FieldKey_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Field_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Field_reflection_ = NULL;
+const ::google::protobuf::Descriptor* FieldOperation_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  FieldOperation_reflection_ = NULL;
+const ::google::protobuf::EnumDescriptor* FieldOperation_OperationType_descriptor_ = NULL;
+const ::google::protobuf::Descriptor* ChannelState_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ChannelState_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_presence_5ftypes_2eproto() {
+  protobuf_AddDesc_presence_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "presence_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  RichPresenceLocalizationKey_descriptor_ = file->message_type(0);
+  static const int RichPresenceLocalizationKey_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RichPresenceLocalizationKey, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RichPresenceLocalizationKey, stream_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RichPresenceLocalizationKey, localization_id_),
+  };
+  RichPresenceLocalizationKey_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RichPresenceLocalizationKey_descriptor_,
+      RichPresenceLocalizationKey::default_instance_,
+      RichPresenceLocalizationKey_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RichPresenceLocalizationKey, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RichPresenceLocalizationKey, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RichPresenceLocalizationKey));
+  FieldKey_descriptor_ = file->message_type(1);
+  static const int FieldKey_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldKey, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldKey, group_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldKey, field_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldKey, unique_id_),
+  };
+  FieldKey_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      FieldKey_descriptor_,
+      FieldKey::default_instance_,
+      FieldKey_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldKey, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldKey, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(FieldKey));
+  Field_descriptor_ = file->message_type(2);
+  static const int Field_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Field, key_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Field, value_),
+  };
+  Field_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Field_descriptor_,
+      Field::default_instance_,
+      Field_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Field, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Field, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Field));
+  FieldOperation_descriptor_ = file->message_type(3);
+  static const int FieldOperation_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOperation, field_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOperation, operation_),
+  };
+  FieldOperation_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      FieldOperation_descriptor_,
+      FieldOperation::default_instance_,
+      FieldOperation_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOperation, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOperation, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(FieldOperation));
+  FieldOperation_OperationType_descriptor_ = FieldOperation_descriptor_->enum_type(0);
+  ChannelState_descriptor_ = file->message_type(4);
+  static const int ChannelState_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, entity_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, field_operation_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, healing_),
+  };
+  ChannelState_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ChannelState_descriptor_,
+      ChannelState::default_instance_,
+      ChannelState_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ChannelState, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ChannelState));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_presence_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RichPresenceLocalizationKey_descriptor_, &RichPresenceLocalizationKey::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    FieldKey_descriptor_, &FieldKey::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Field_descriptor_, &Field::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    FieldOperation_descriptor_, &FieldOperation::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ChannelState_descriptor_, &ChannelState::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_presence_5ftypes_2eproto() {
+  delete RichPresenceLocalizationKey::default_instance_;
+  delete RichPresenceLocalizationKey_reflection_;
+  delete FieldKey::default_instance_;
+  delete FieldKey_reflection_;
+  delete Field::default_instance_;
+  delete Field_reflection_;
+  delete FieldOperation::default_instance_;
+  delete FieldOperation_reflection_;
+  delete ChannelState::default_instance_;
+  delete ChannelState_reflection_;
+}
+
+void protobuf_AddDesc_presence_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::bgs::protocol::channel::v1::protobuf_AddDesc_channel_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\024presence_types.proto\022\030bgs.protocol.pre"
+    "sence.v1\032\025attribute_types.proto\032\022entity_"
+    "types.proto\032\023channel_types.proto\"W\n\033Rich"
+    "PresenceLocalizationKey\022\017\n\007program\030\001 \002(\007"
+    "\022\016\n\006stream\030\002 \002(\007\022\027\n\017localization_id\030\003 \002("
+    "\r\"O\n\010FieldKey\022\017\n\007program\030\001 \002(\r\022\r\n\005group\030"
+    "\002 \002(\r\022\r\n\005field\030\003 \002(\r\022\024\n\tunique_id\030\004 \001(\004:"
+    "\0010\"^\n\005Field\022/\n\003key\030\001 \002(\0132\".bgs.protocol."
+    "presence.v1.FieldKey\022$\n\005value\030\002 \002(\0132\025.bg"
+    "s.protocol.Variant\"\265\001\n\016FieldOperation\022.\n"
+    "\005field\030\001 \002(\0132\037.bgs.protocol.presence.v1."
+    "Field\022N\n\toperation\030\002 \001(\01626.bgs.protocol."
+    "presence.v1.FieldOperation.OperationType"
+    ":\003SET\"#\n\rOperationType\022\007\n\003SET\020\000\022\t\n\005CLEAR"
+    "\020\001\"\365\001\n\014ChannelState\022)\n\tentity_id\030\001 \001(\0132\026"
+    ".bgs.protocol.EntityId\022A\n\017field_operatio"
+    "n\030\002 \003(\0132(.bgs.protocol.presence.v1.Field"
+    "Operation\022\026\n\007healing\030\003 \001(\010:\005false2_\n\010pre"
+    "sence\022%.bgs.protocol.channel.v1.ChannelS"
+    "tate\030e \001(\0132&.bgs.protocol.presence.v1.Ch"
+    "annelStateB\002H\001", 814);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "presence_types.proto", &protobuf_RegisterTypes);
+  RichPresenceLocalizationKey::default_instance_ = new RichPresenceLocalizationKey();
+  FieldKey::default_instance_ = new FieldKey();
+  Field::default_instance_ = new Field();
+  FieldOperation::default_instance_ = new FieldOperation();
+  ChannelState::default_instance_ = new ChannelState();
+  RichPresenceLocalizationKey::default_instance_->InitAsDefaultInstance();
+  FieldKey::default_instance_->InitAsDefaultInstance();
+  Field::default_instance_->InitAsDefaultInstance();
+  FieldOperation::default_instance_->InitAsDefaultInstance();
+  ChannelState::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::ExtensionSet::RegisterMessageExtension(
+    &::bgs::protocol::channel::v1::ChannelState::default_instance(),
+    101, 11, false, false,
+    &::bgs::protocol::presence::v1::ChannelState::default_instance());
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_presence_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_presence_5ftypes_2eproto {
+  StaticDescriptorInitializer_presence_5ftypes_2eproto() {
+    protobuf_AddDesc_presence_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_presence_5ftypes_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RichPresenceLocalizationKey::kProgramFieldNumber;
+const int RichPresenceLocalizationKey::kStreamFieldNumber;
+const int RichPresenceLocalizationKey::kLocalizationIdFieldNumber;
+#endif  // !_MSC_VER
+
+RichPresenceLocalizationKey::RichPresenceLocalizationKey()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.RichPresenceLocalizationKey)
+}
+
+void RichPresenceLocalizationKey::InitAsDefaultInstance() {
+}
+
+RichPresenceLocalizationKey::RichPresenceLocalizationKey(const RichPresenceLocalizationKey& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.RichPresenceLocalizationKey)
+}
+
+void RichPresenceLocalizationKey::SharedCtor() {
+  _cached_size_ = 0;
+  program_ = 0u;
+  stream_ = 0u;
+  localization_id_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RichPresenceLocalizationKey::~RichPresenceLocalizationKey() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.RichPresenceLocalizationKey)
+  SharedDtor();
+}
+
+void RichPresenceLocalizationKey::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void RichPresenceLocalizationKey::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RichPresenceLocalizationKey::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RichPresenceLocalizationKey_descriptor_;
+}
+
+const RichPresenceLocalizationKey& RichPresenceLocalizationKey::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+RichPresenceLocalizationKey* RichPresenceLocalizationKey::default_instance_ = NULL;
+
+RichPresenceLocalizationKey* RichPresenceLocalizationKey::New() const {
+  return new RichPresenceLocalizationKey;
+}
+
+void RichPresenceLocalizationKey::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<RichPresenceLocalizationKey*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(program_, localization_id_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RichPresenceLocalizationKey::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.RichPresenceLocalizationKey)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required fixed32 program = 1;
+      case 1: {
+        if (tag == 13) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(21)) goto parse_stream;
+        break;
+      }
+
+      // required fixed32 stream = 2;
+      case 2: {
+        if (tag == 21) {
+         parse_stream:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &stream_)));
+          set_has_stream();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_localization_id;
+        break;
+      }
+
+      // required uint32 localization_id = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_localization_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &localization_id_)));
+          set_has_localization_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.RichPresenceLocalizationKey)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.RichPresenceLocalizationKey)
+  return false;
+#undef DO_
+}
+
+void RichPresenceLocalizationKey::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.RichPresenceLocalizationKey)
+  // required fixed32 program = 1;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->program(), output);
+  }
+
+  // required fixed32 stream = 2;
+  if (has_stream()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->stream(), output);
+  }
+
+  // required uint32 localization_id = 3;
+  if (has_localization_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->localization_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.RichPresenceLocalizationKey)
+}
+
+::google::protobuf::uint8* RichPresenceLocalizationKey::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.RichPresenceLocalizationKey)
+  // required fixed32 program = 1;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->program(), target);
+  }
+
+  // required fixed32 stream = 2;
+  if (has_stream()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->stream(), target);
+  }
+
+  // required uint32 localization_id = 3;
+  if (has_localization_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->localization_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.RichPresenceLocalizationKey)
+  return target;
+}
+
+int RichPresenceLocalizationKey::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required fixed32 program = 1;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+    // required fixed32 stream = 2;
+    if (has_stream()) {
+      total_size += 1 + 4;
+    }
+
+    // required uint32 localization_id = 3;
+    if (has_localization_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->localization_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RichPresenceLocalizationKey::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RichPresenceLocalizationKey* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RichPresenceLocalizationKey*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RichPresenceLocalizationKey::MergeFrom(const RichPresenceLocalizationKey& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_stream()) {
+      set_stream(from.stream());
+    }
+    if (from.has_localization_id()) {
+      set_localization_id(from.localization_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RichPresenceLocalizationKey::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RichPresenceLocalizationKey::CopyFrom(const RichPresenceLocalizationKey& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RichPresenceLocalizationKey::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
+
+  return true;
+}
+
+void RichPresenceLocalizationKey::Swap(RichPresenceLocalizationKey* other) {
+  if (other != this) {
+    std::swap(program_, other->program_);
+    std::swap(stream_, other->stream_);
+    std::swap(localization_id_, other->localization_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RichPresenceLocalizationKey::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RichPresenceLocalizationKey_descriptor_;
+  metadata.reflection = RichPresenceLocalizationKey_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int FieldKey::kProgramFieldNumber;
+const int FieldKey::kGroupFieldNumber;
+const int FieldKey::kFieldFieldNumber;
+const int FieldKey::kUniqueIdFieldNumber;
+#endif  // !_MSC_VER
+
+FieldKey::FieldKey()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.FieldKey)
+}
+
+void FieldKey::InitAsDefaultInstance() {
+}
+
+FieldKey::FieldKey(const FieldKey& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.FieldKey)
+}
+
+void FieldKey::SharedCtor() {
+  _cached_size_ = 0;
+  program_ = 0u;
+  group_ = 0u;
+  field_ = 0u;
+  unique_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+FieldKey::~FieldKey() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.FieldKey)
+  SharedDtor();
+}
+
+void FieldKey::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void FieldKey::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* FieldKey::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return FieldKey_descriptor_;
+}
+
+const FieldKey& FieldKey::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+FieldKey* FieldKey::default_instance_ = NULL;
+
+FieldKey* FieldKey::New() const {
+  return new FieldKey;
+}
+
+void FieldKey::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<FieldKey*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(program_, field_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool FieldKey::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.FieldKey)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required uint32 program = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_group;
+        break;
+      }
+
+      // required uint32 group = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_group:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &group_)));
+          set_has_group();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_field;
+        break;
+      }
+
+      // required uint32 field = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_field:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &field_)));
+          set_has_field();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_unique_id;
+        break;
+      }
+
+      // optional uint64 unique_id = 4 [default = 0];
+      case 4: {
+        if (tag == 32) {
+         parse_unique_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &unique_id_)));
+          set_has_unique_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.FieldKey)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.FieldKey)
+  return false;
+#undef DO_
+}
+
+void FieldKey::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.FieldKey)
+  // required uint32 program = 1;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->program(), output);
+  }
+
+  // required uint32 group = 2;
+  if (has_group()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->group(), output);
+  }
+
+  // required uint32 field = 3;
+  if (has_field()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->field(), output);
+  }
+
+  // optional uint64 unique_id = 4 [default = 0];
+  if (has_unique_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->unique_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.FieldKey)
+}
+
+::google::protobuf::uint8* FieldKey::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.FieldKey)
+  // required uint32 program = 1;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->program(), target);
+  }
+
+  // required uint32 group = 2;
+  if (has_group()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->group(), target);
+  }
+
+  // required uint32 field = 3;
+  if (has_field()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->field(), target);
+  }
+
+  // optional uint64 unique_id = 4 [default = 0];
+  if (has_unique_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->unique_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.FieldKey)
+  return target;
+}
+
+int FieldKey::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 program = 1;
+    if (has_program()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->program());
+    }
+
+    // required uint32 group = 2;
+    if (has_group()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->group());
+    }
+
+    // required uint32 field = 3;
+    if (has_field()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->field());
+    }
+
+    // optional uint64 unique_id = 4 [default = 0];
+    if (has_unique_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->unique_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FieldKey::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const FieldKey* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const FieldKey*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void FieldKey::MergeFrom(const FieldKey& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_group()) {
+      set_group(from.group());
+    }
+    if (from.has_field()) {
+      set_field(from.field());
+    }
+    if (from.has_unique_id()) {
+      set_unique_id(from.unique_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void FieldKey::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void FieldKey::CopyFrom(const FieldKey& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FieldKey::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
+
+  return true;
+}
+
+void FieldKey::Swap(FieldKey* other) {
+  if (other != this) {
+    std::swap(program_, other->program_);
+    std::swap(group_, other->group_);
+    std::swap(field_, other->field_);
+    std::swap(unique_id_, other->unique_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata FieldKey::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = FieldKey_descriptor_;
+  metadata.reflection = FieldKey_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Field::kKeyFieldNumber;
+const int Field::kValueFieldNumber;
+#endif  // !_MSC_VER
+
+Field::Field()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.Field)
+}
+
+void Field::InitAsDefaultInstance() {
+  key_ = const_cast< ::bgs::protocol::presence::v1::FieldKey*>(&::bgs::protocol::presence::v1::FieldKey::default_instance());
+  value_ = const_cast< ::bgs::protocol::Variant*>(&::bgs::protocol::Variant::default_instance());
+}
+
+Field::Field(const Field& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.Field)
+}
+
+void Field::SharedCtor() {
+  _cached_size_ = 0;
+  key_ = NULL;
+  value_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Field::~Field() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.Field)
+  SharedDtor();
+}
+
+void Field::SharedDtor() {
+  if (this != default_instance_) {
+    delete key_;
+    delete value_;
+  }
+}
+
+void Field::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Field::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Field_descriptor_;
+}
+
+const Field& Field::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Field* Field::default_instance_ = NULL;
+
+Field* Field::New() const {
+  return new Field;
+}
+
+void Field::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_key()) {
+      if (key_ != NULL) key_->::bgs::protocol::presence::v1::FieldKey::Clear();
+    }
+    if (has_value()) {
+      if (value_ != NULL) value_->::bgs::protocol::Variant::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Field::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.Field)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.presence.v1.FieldKey key = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_key()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_value;
+        break;
+      }
+
+      // required .bgs.protocol.Variant value = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_value:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_value()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.Field)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.Field)
+  return false;
+#undef DO_
+}
+
+void Field::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.Field)
+  // required .bgs.protocol.presence.v1.FieldKey key = 1;
+  if (has_key()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->key(), output);
+  }
+
+  // required .bgs.protocol.Variant value = 2;
+  if (has_value()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->value(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.Field)
+}
+
+::google::protobuf::uint8* Field::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.Field)
+  // required .bgs.protocol.presence.v1.FieldKey key = 1;
+  if (has_key()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->key(), target);
+  }
+
+  // required .bgs.protocol.Variant value = 2;
+  if (has_value()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->value(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.Field)
+  return target;
+}
+
+int Field::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.presence.v1.FieldKey key = 1;
+    if (has_key()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->key());
+    }
+
+    // required .bgs.protocol.Variant value = 2;
+    if (has_value()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->value());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Field::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Field* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Field*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Field::MergeFrom(const Field& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_key()) {
+      mutable_key()->::bgs::protocol::presence::v1::FieldKey::MergeFrom(from.key());
+    }
+    if (from.has_value()) {
+      mutable_value()->::bgs::protocol::Variant::MergeFrom(from.value());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Field::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Field::CopyFrom(const Field& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Field::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  if (has_key()) {
+    if (!this->key().IsInitialized()) return false;
+  }
+  if (has_value()) {
+    if (!this->value().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void Field::Swap(Field* other) {
+  if (other != this) {
+    std::swap(key_, other->key_);
+    std::swap(value_, other->value_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Field::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Field_descriptor_;
+  metadata.reflection = Field_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+const ::google::protobuf::EnumDescriptor* FieldOperation_OperationType_descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return FieldOperation_OperationType_descriptor_;
+}
+bool FieldOperation_OperationType_IsValid(int value) {
+  switch(value) {
+    case 0:
+    case 1:
+      return true;
+    default:
+      return false;
+  }
+}
+
+#ifndef _MSC_VER
+const FieldOperation_OperationType FieldOperation::SET;
+const FieldOperation_OperationType FieldOperation::CLEAR;
+const FieldOperation_OperationType FieldOperation::OperationType_MIN;
+const FieldOperation_OperationType FieldOperation::OperationType_MAX;
+const int FieldOperation::OperationType_ARRAYSIZE;
+#endif  // _MSC_VER
+#ifndef _MSC_VER
+const int FieldOperation::kFieldFieldNumber;
+const int FieldOperation::kOperationFieldNumber;
+#endif  // !_MSC_VER
+
+FieldOperation::FieldOperation()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.FieldOperation)
+}
+
+void FieldOperation::InitAsDefaultInstance() {
+  field_ = const_cast< ::bgs::protocol::presence::v1::Field*>(&::bgs::protocol::presence::v1::Field::default_instance());
+}
+
+FieldOperation::FieldOperation(const FieldOperation& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.FieldOperation)
+}
+
+void FieldOperation::SharedCtor() {
+  _cached_size_ = 0;
+  field_ = NULL;
+  operation_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+FieldOperation::~FieldOperation() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.FieldOperation)
+  SharedDtor();
+}
+
+void FieldOperation::SharedDtor() {
+  if (this != default_instance_) {
+    delete field_;
+  }
+}
+
+void FieldOperation::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* FieldOperation::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return FieldOperation_descriptor_;
+}
+
+const FieldOperation& FieldOperation::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+FieldOperation* FieldOperation::default_instance_ = NULL;
+
+FieldOperation* FieldOperation::New() const {
+  return new FieldOperation;
+}
+
+void FieldOperation::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_field()) {
+      if (field_ != NULL) field_->::bgs::protocol::presence::v1::Field::Clear();
+    }
+    operation_ = 0;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool FieldOperation::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.FieldOperation)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.presence.v1.Field field = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_field()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_operation;
+        break;
+      }
+
+      // optional .bgs.protocol.presence.v1.FieldOperation.OperationType operation = 2 [default = SET];
+      case 2: {
+        if (tag == 16) {
+         parse_operation:
+          int value;
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
+                 input, &value)));
+          if (::bgs::protocol::presence::v1::FieldOperation_OperationType_IsValid(value)) {
+            set_operation(static_cast< ::bgs::protocol::presence::v1::FieldOperation_OperationType >(value));
+          } else {
+            mutable_unknown_fields()->AddVarint(2, value);
+          }
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.FieldOperation)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.FieldOperation)
+  return false;
+#undef DO_
+}
+
+void FieldOperation::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.FieldOperation)
+  // required .bgs.protocol.presence.v1.Field field = 1;
+  if (has_field()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->field(), output);
+  }
+
+  // optional .bgs.protocol.presence.v1.FieldOperation.OperationType operation = 2 [default = SET];
+  if (has_operation()) {
+    ::google::protobuf::internal::WireFormatLite::WriteEnum(
+      2, this->operation(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.FieldOperation)
+}
+
+::google::protobuf::uint8* FieldOperation::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.FieldOperation)
+  // required .bgs.protocol.presence.v1.Field field = 1;
+  if (has_field()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->field(), target);
+  }
+
+  // optional .bgs.protocol.presence.v1.FieldOperation.OperationType operation = 2 [default = SET];
+  if (has_operation()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
+      2, this->operation(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.FieldOperation)
+  return target;
+}
+
+int FieldOperation::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.presence.v1.Field field = 1;
+    if (has_field()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->field());
+    }
+
+    // optional .bgs.protocol.presence.v1.FieldOperation.OperationType operation = 2 [default = SET];
+    if (has_operation()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::EnumSize(this->operation());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void FieldOperation::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const FieldOperation* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const FieldOperation*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void FieldOperation::MergeFrom(const FieldOperation& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_field()) {
+      mutable_field()->::bgs::protocol::presence::v1::Field::MergeFrom(from.field());
+    }
+    if (from.has_operation()) {
+      set_operation(from.operation());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void FieldOperation::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void FieldOperation::CopyFrom(const FieldOperation& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool FieldOperation::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_field()) {
+    if (!this->field().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void FieldOperation::Swap(FieldOperation* other) {
+  if (other != this) {
+    std::swap(field_, other->field_);
+    std::swap(operation_, other->operation_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata FieldOperation::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = FieldOperation_descriptor_;
+  metadata.reflection = FieldOperation_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ChannelState::kEntityIdFieldNumber;
+const int ChannelState::kFieldOperationFieldNumber;
+const int ChannelState::kHealingFieldNumber;
+#endif  // !_MSC_VER
+
+#ifndef _MSC_VER
+const int ChannelState::kPresenceFieldNumber;
+#endif
+::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::channel::v1::ChannelState,
+    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::presence::v1::ChannelState >, 11, false >
+  ChannelState::presence(kPresenceFieldNumber, ::bgs::protocol::presence::v1::ChannelState::default_instance());
+ChannelState::ChannelState()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.presence.v1.ChannelState)
+}
+
+void ChannelState::InitAsDefaultInstance() {
+  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+ChannelState::ChannelState(const ChannelState& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.presence.v1.ChannelState)
+}
+
+void ChannelState::SharedCtor() {
+  _cached_size_ = 0;
+  entity_id_ = NULL;
+  healing_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ChannelState::~ChannelState() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.presence.v1.ChannelState)
+  SharedDtor();
+}
+
+void ChannelState::SharedDtor() {
+  if (this != default_instance_) {
+    delete entity_id_;
+  }
+}
+
+void ChannelState::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ChannelState::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ChannelState_descriptor_;
+}
+
+const ChannelState& ChannelState::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_presence_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ChannelState* ChannelState::default_instance_ = NULL;
+
+ChannelState* ChannelState::New() const {
+  return new ChannelState;
+}
+
+void ChannelState::Clear() {
+  if (_has_bits_[0 / 32] & 5) {
+    if (has_entity_id()) {
+      if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+    }
+    healing_ = false;
+  }
+  field_operation_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ChannelState::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.presence.v1.ChannelState)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId entity_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_field_operation;
+        break;
+      }
+
+      // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_field_operation:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_field_operation()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_field_operation;
+        if (input->ExpectTag(24)) goto parse_healing;
+        break;
+      }
+
+      // optional bool healing = 3 [default = false];
+      case 3: {
+        if (tag == 24) {
+         parse_healing:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &healing_)));
+          set_has_healing();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.presence.v1.ChannelState)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.presence.v1.ChannelState)
+  return false;
+#undef DO_
+}
+
+void ChannelState::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.presence.v1.ChannelState)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->entity_id(), output);
+  }
+
+  // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+  for (int i = 0; i < this->field_operation_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->field_operation(i), output);
+  }
+
+  // optional bool healing = 3 [default = false];
+  if (has_healing()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(3, this->healing(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.presence.v1.ChannelState)
+}
+
+::google::protobuf::uint8* ChannelState::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.presence.v1.ChannelState)
+  // optional .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->entity_id(), target);
+  }
+
+  // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+  for (int i = 0; i < this->field_operation_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->field_operation(i), target);
+  }
+
+  // optional bool healing = 3 [default = false];
+  if (has_healing()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(3, this->healing(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.presence.v1.ChannelState)
+  return target;
+}
+
+int ChannelState::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId entity_id = 1;
+    if (has_entity_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+    }
+
+    // optional bool healing = 3 [default = false];
+    if (has_healing()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+  total_size += 1 * this->field_operation_size();
+  for (int i = 0; i < this->field_operation_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->field_operation(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ChannelState::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ChannelState* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ChannelState*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ChannelState::MergeFrom(const ChannelState& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  field_operation_.MergeFrom(from.field_operation_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_entity_id()) {
+      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
+    }
+    if (from.has_healing()) {
+      set_healing(from.healing());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ChannelState::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ChannelState::CopyFrom(const ChannelState& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ChannelState::IsInitialized() const {
+
+  if (has_entity_id()) {
+    if (!this->entity_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->field_operation())) return false;
+  return true;
+}
+
+void ChannelState::Swap(ChannelState* other) {
+  if (other != this) {
+    std::swap(entity_id_, other->entity_id_);
+    field_operation_.Swap(&other->field_operation_);
+    std::swap(healing_, other->healing_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ChannelState::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ChannelState_descriptor_;
+  metadata.reflection = ChannelState_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace presence
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/presence_types.pb.h b/src/server/proto/Client/presence_types.pb.h
new file mode 100644
index 00000000000..c77b517bd58
--- /dev/null
+++ b/src/server/proto/Client/presence_types.pb.h
@@ -0,0 +1,1054 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: presence_types.proto
+
+#ifndef PROTOBUF_presence_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_presence_5ftypes_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/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "attribute_types.pb.h"
+#include "entity_types.pb.h"
+#include "channel_types.pb.h"
+#include "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace presence {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_presence_5ftypes_2eproto();
+void protobuf_AssignDesc_presence_5ftypes_2eproto();
+void protobuf_ShutdownFile_presence_5ftypes_2eproto();
+
+class RichPresenceLocalizationKey;
+class FieldKey;
+class Field;
+class FieldOperation;
+class ChannelState;
+
+enum FieldOperation_OperationType {
+  FieldOperation_OperationType_SET = 0,
+  FieldOperation_OperationType_CLEAR = 1
+};
+TC_SHARED_API bool FieldOperation_OperationType_IsValid(int value);
+const FieldOperation_OperationType FieldOperation_OperationType_OperationType_MIN = FieldOperation_OperationType_SET;
+const FieldOperation_OperationType FieldOperation_OperationType_OperationType_MAX = FieldOperation_OperationType_CLEAR;
+const int FieldOperation_OperationType_OperationType_ARRAYSIZE = FieldOperation_OperationType_OperationType_MAX + 1;
+
+TC_SHARED_API const ::google::protobuf::EnumDescriptor* FieldOperation_OperationType_descriptor();
+inline const ::std::string& FieldOperation_OperationType_Name(FieldOperation_OperationType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    FieldOperation_OperationType_descriptor(), value);
+}
+inline bool FieldOperation_OperationType_Parse(
+    const ::std::string& name, FieldOperation_OperationType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<FieldOperation_OperationType>(
+    FieldOperation_OperationType_descriptor(), name, value);
+}
+// ===================================================================
+
+class TC_SHARED_API RichPresenceLocalizationKey : public ::google::protobuf::Message {
+ public:
+  RichPresenceLocalizationKey();
+  virtual ~RichPresenceLocalizationKey();
+
+  RichPresenceLocalizationKey(const RichPresenceLocalizationKey& from);
+
+  inline RichPresenceLocalizationKey& operator=(const RichPresenceLocalizationKey& 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 RichPresenceLocalizationKey& default_instance();
+
+  void Swap(RichPresenceLocalizationKey* other);
+
+  // implements Message ----------------------------------------------
+
+  RichPresenceLocalizationKey* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RichPresenceLocalizationKey& from);
+  void MergeFrom(const RichPresenceLocalizationKey& 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 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);
+
+  // required fixed32 stream = 2;
+  inline bool has_stream() const;
+  inline void clear_stream();
+  static const int kStreamFieldNumber = 2;
+  inline ::google::protobuf::uint32 stream() const;
+  inline void set_stream(::google::protobuf::uint32 value);
+
+  // required uint32 localization_id = 3;
+  inline bool has_localization_id() const;
+  inline void clear_localization_id();
+  static const int kLocalizationIdFieldNumber = 3;
+  inline ::google::protobuf::uint32 localization_id() const;
+  inline void set_localization_id(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.RichPresenceLocalizationKey)
+ private:
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_stream();
+  inline void clear_has_stream();
+  inline void set_has_localization_id();
+  inline void clear_has_localization_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 program_;
+  ::google::protobuf::uint32 stream_;
+  ::google::protobuf::uint32 localization_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_presence_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_presence_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_presence_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static RichPresenceLocalizationKey* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API FieldKey : public ::google::protobuf::Message {
+ public:
+  FieldKey();
+  virtual ~FieldKey();
+
+  FieldKey(const FieldKey& from);
+
+  inline FieldKey& operator=(const FieldKey& 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 FieldKey& default_instance();
+
+  void Swap(FieldKey* other);
+
+  // implements Message ----------------------------------------------
+
+  FieldKey* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const FieldKey& from);
+  void MergeFrom(const FieldKey& 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 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);
+
+  // required uint32 group = 2;
+  inline bool has_group() const;
+  inline void clear_group();
+  static const int kGroupFieldNumber = 2;
+  inline ::google::protobuf::uint32 group() const;
+  inline void set_group(::google::protobuf::uint32 value);
+
+  // required uint32 field = 3;
+  inline bool has_field() const;
+  inline void clear_field();
+  static const int kFieldFieldNumber = 3;
+  inline ::google::protobuf::uint32 field() const;
+  inline void set_field(::google::protobuf::uint32 value);
+
+  // optional uint64 unique_id = 4 [default = 0];
+  inline bool has_unique_id() const;
+  inline void clear_unique_id();
+  static const int kUniqueIdFieldNumber = 4;
+  inline ::google::protobuf::uint64 unique_id() const;
+  inline void set_unique_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.FieldKey)
+ private:
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_group();
+  inline void clear_has_group();
+  inline void set_has_field();
+  inline void clear_has_field();
+  inline void set_has_unique_id();
+  inline void clear_has_unique_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 program_;
+  ::google::protobuf::uint32 group_;
+  ::google::protobuf::uint64 unique_id_;
+  ::google::protobuf::uint32 field_;
+  friend void TC_SHARED_API protobuf_AddDesc_presence_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_presence_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_presence_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static FieldKey* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API Field : public ::google::protobuf::Message {
+ public:
+  Field();
+  virtual ~Field();
+
+  Field(const Field& from);
+
+  inline Field& operator=(const Field& 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 Field& default_instance();
+
+  void Swap(Field* other);
+
+  // implements Message ----------------------------------------------
+
+  Field* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Field& from);
+  void MergeFrom(const Field& 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.presence.v1.FieldKey key = 1;
+  inline bool has_key() const;
+  inline void clear_key();
+  static const int kKeyFieldNumber = 1;
+  inline const ::bgs::protocol::presence::v1::FieldKey& key() const;
+  inline ::bgs::protocol::presence::v1::FieldKey* mutable_key();
+  inline ::bgs::protocol::presence::v1::FieldKey* release_key();
+  inline void set_allocated_key(::bgs::protocol::presence::v1::FieldKey* key);
+
+  // required .bgs.protocol.Variant value = 2;
+  inline bool has_value() const;
+  inline void clear_value();
+  static const int kValueFieldNumber = 2;
+  inline const ::bgs::protocol::Variant& value() const;
+  inline ::bgs::protocol::Variant* mutable_value();
+  inline ::bgs::protocol::Variant* release_value();
+  inline void set_allocated_value(::bgs::protocol::Variant* value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.Field)
+ private:
+  inline void set_has_key();
+  inline void clear_has_key();
+  inline void set_has_value();
+  inline void clear_has_value();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::presence::v1::FieldKey* key_;
+  ::bgs::protocol::Variant* value_;
+  friend void TC_SHARED_API protobuf_AddDesc_presence_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_presence_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_presence_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Field* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API FieldOperation : public ::google::protobuf::Message {
+ public:
+  FieldOperation();
+  virtual ~FieldOperation();
+
+  FieldOperation(const FieldOperation& from);
+
+  inline FieldOperation& operator=(const FieldOperation& 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 FieldOperation& default_instance();
+
+  void Swap(FieldOperation* other);
+
+  // implements Message ----------------------------------------------
+
+  FieldOperation* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const FieldOperation& from);
+  void MergeFrom(const FieldOperation& 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 ----------------------------------------------------
+
+  typedef FieldOperation_OperationType OperationType;
+  static const OperationType SET = FieldOperation_OperationType_SET;
+  static const OperationType CLEAR = FieldOperation_OperationType_CLEAR;
+  static inline bool OperationType_IsValid(int value) {
+    return FieldOperation_OperationType_IsValid(value);
+  }
+  static const OperationType OperationType_MIN =
+    FieldOperation_OperationType_OperationType_MIN;
+  static const OperationType OperationType_MAX =
+    FieldOperation_OperationType_OperationType_MAX;
+  static const int OperationType_ARRAYSIZE =
+    FieldOperation_OperationType_OperationType_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  OperationType_descriptor() {
+    return FieldOperation_OperationType_descriptor();
+  }
+  static inline const ::std::string& OperationType_Name(OperationType value) {
+    return FieldOperation_OperationType_Name(value);
+  }
+  static inline bool OperationType_Parse(const ::std::string& name,
+      OperationType* value) {
+    return FieldOperation_OperationType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  // required .bgs.protocol.presence.v1.Field field = 1;
+  inline bool has_field() const;
+  inline void clear_field();
+  static const int kFieldFieldNumber = 1;
+  inline const ::bgs::protocol::presence::v1::Field& field() const;
+  inline ::bgs::protocol::presence::v1::Field* mutable_field();
+  inline ::bgs::protocol::presence::v1::Field* release_field();
+  inline void set_allocated_field(::bgs::protocol::presence::v1::Field* field);
+
+  // optional .bgs.protocol.presence.v1.FieldOperation.OperationType operation = 2 [default = SET];
+  inline bool has_operation() const;
+  inline void clear_operation();
+  static const int kOperationFieldNumber = 2;
+  inline ::bgs::protocol::presence::v1::FieldOperation_OperationType operation() const;
+  inline void set_operation(::bgs::protocol::presence::v1::FieldOperation_OperationType value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.FieldOperation)
+ private:
+  inline void set_has_field();
+  inline void clear_has_field();
+  inline void set_has_operation();
+  inline void clear_has_operation();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::presence::v1::Field* field_;
+  int operation_;
+  friend void TC_SHARED_API protobuf_AddDesc_presence_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_presence_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_presence_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static FieldOperation* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ChannelState : public ::google::protobuf::Message {
+ public:
+  ChannelState();
+  virtual ~ChannelState();
+
+  ChannelState(const ChannelState& from);
+
+  inline ChannelState& operator=(const ChannelState& 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 ChannelState& default_instance();
+
+  void Swap(ChannelState* other);
+
+  // implements Message ----------------------------------------------
+
+  ChannelState* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ChannelState& from);
+  void MergeFrom(const ChannelState& 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.EntityId entity_id = 1;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+  inline int field_operation_size() const;
+  inline void clear_field_operation();
+  static const int kFieldOperationFieldNumber = 2;
+  inline const ::bgs::protocol::presence::v1::FieldOperation& field_operation(int index) const;
+  inline ::bgs::protocol::presence::v1::FieldOperation* mutable_field_operation(int index);
+  inline ::bgs::protocol::presence::v1::FieldOperation* add_field_operation();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >&
+      field_operation() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >*
+      mutable_field_operation();
+
+  // optional bool healing = 3 [default = false];
+  inline bool has_healing() const;
+  inline void clear_healing();
+  static const int kHealingFieldNumber = 3;
+  inline bool healing() const;
+  inline void set_healing(bool value);
+
+  static const int kPresenceFieldNumber = 101;
+  static ::google::protobuf::internal::ExtensionIdentifier< ::bgs::protocol::channel::v1::ChannelState,
+      ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::presence::v1::ChannelState >, 11, false >
+    presence;
+  // @@protoc_insertion_point(class_scope:bgs.protocol.presence.v1.ChannelState)
+ private:
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+  inline void set_has_healing();
+  inline void clear_has_healing();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* entity_id_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation > field_operation_;
+  bool healing_;
+  friend void TC_SHARED_API protobuf_AddDesc_presence_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_presence_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_presence_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ChannelState* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// RichPresenceLocalizationKey
+
+// required fixed32 program = 1;
+inline bool RichPresenceLocalizationKey::has_program() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RichPresenceLocalizationKey::set_has_program() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RichPresenceLocalizationKey::clear_has_program() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RichPresenceLocalizationKey::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 RichPresenceLocalizationKey::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.RichPresenceLocalizationKey.program)
+  return program_;
+}
+inline void RichPresenceLocalizationKey::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.RichPresenceLocalizationKey.program)
+}
+
+// required fixed32 stream = 2;
+inline bool RichPresenceLocalizationKey::has_stream() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RichPresenceLocalizationKey::set_has_stream() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RichPresenceLocalizationKey::clear_has_stream() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RichPresenceLocalizationKey::clear_stream() {
+  stream_ = 0u;
+  clear_has_stream();
+}
+inline ::google::protobuf::uint32 RichPresenceLocalizationKey::stream() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.RichPresenceLocalizationKey.stream)
+  return stream_;
+}
+inline void RichPresenceLocalizationKey::set_stream(::google::protobuf::uint32 value) {
+  set_has_stream();
+  stream_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.RichPresenceLocalizationKey.stream)
+}
+
+// required uint32 localization_id = 3;
+inline bool RichPresenceLocalizationKey::has_localization_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void RichPresenceLocalizationKey::set_has_localization_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void RichPresenceLocalizationKey::clear_has_localization_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void RichPresenceLocalizationKey::clear_localization_id() {
+  localization_id_ = 0u;
+  clear_has_localization_id();
+}
+inline ::google::protobuf::uint32 RichPresenceLocalizationKey::localization_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.RichPresenceLocalizationKey.localization_id)
+  return localization_id_;
+}
+inline void RichPresenceLocalizationKey::set_localization_id(::google::protobuf::uint32 value) {
+  set_has_localization_id();
+  localization_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.RichPresenceLocalizationKey.localization_id)
+}
+
+// -------------------------------------------------------------------
+
+// FieldKey
+
+// required uint32 program = 1;
+inline bool FieldKey::has_program() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FieldKey::set_has_program() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FieldKey::clear_has_program() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FieldKey::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 FieldKey::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.FieldKey.program)
+  return program_;
+}
+inline void FieldKey::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.FieldKey.program)
+}
+
+// required uint32 group = 2;
+inline bool FieldKey::has_group() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void FieldKey::set_has_group() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void FieldKey::clear_has_group() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void FieldKey::clear_group() {
+  group_ = 0u;
+  clear_has_group();
+}
+inline ::google::protobuf::uint32 FieldKey::group() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.FieldKey.group)
+  return group_;
+}
+inline void FieldKey::set_group(::google::protobuf::uint32 value) {
+  set_has_group();
+  group_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.FieldKey.group)
+}
+
+// required uint32 field = 3;
+inline bool FieldKey::has_field() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void FieldKey::set_has_field() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void FieldKey::clear_has_field() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void FieldKey::clear_field() {
+  field_ = 0u;
+  clear_has_field();
+}
+inline ::google::protobuf::uint32 FieldKey::field() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.FieldKey.field)
+  return field_;
+}
+inline void FieldKey::set_field(::google::protobuf::uint32 value) {
+  set_has_field();
+  field_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.FieldKey.field)
+}
+
+// optional uint64 unique_id = 4 [default = 0];
+inline bool FieldKey::has_unique_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void FieldKey::set_has_unique_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void FieldKey::clear_has_unique_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void FieldKey::clear_unique_id() {
+  unique_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_unique_id();
+}
+inline ::google::protobuf::uint64 FieldKey::unique_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.FieldKey.unique_id)
+  return unique_id_;
+}
+inline void FieldKey::set_unique_id(::google::protobuf::uint64 value) {
+  set_has_unique_id();
+  unique_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.FieldKey.unique_id)
+}
+
+// -------------------------------------------------------------------
+
+// Field
+
+// required .bgs.protocol.presence.v1.FieldKey key = 1;
+inline bool Field::has_key() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Field::set_has_key() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Field::clear_has_key() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Field::clear_key() {
+  if (key_ != NULL) key_->::bgs::protocol::presence::v1::FieldKey::Clear();
+  clear_has_key();
+}
+inline const ::bgs::protocol::presence::v1::FieldKey& Field::key() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.Field.key)
+  return key_ != NULL ? *key_ : *default_instance_->key_;
+}
+inline ::bgs::protocol::presence::v1::FieldKey* Field::mutable_key() {
+  set_has_key();
+  if (key_ == NULL) key_ = new ::bgs::protocol::presence::v1::FieldKey;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.Field.key)
+  return key_;
+}
+inline ::bgs::protocol::presence::v1::FieldKey* Field::release_key() {
+  clear_has_key();
+  ::bgs::protocol::presence::v1::FieldKey* temp = key_;
+  key_ = NULL;
+  return temp;
+}
+inline void Field::set_allocated_key(::bgs::protocol::presence::v1::FieldKey* key) {
+  delete key_;
+  key_ = key;
+  if (key) {
+    set_has_key();
+  } else {
+    clear_has_key();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.Field.key)
+}
+
+// required .bgs.protocol.Variant value = 2;
+inline bool Field::has_value() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Field::set_has_value() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Field::clear_has_value() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Field::clear_value() {
+  if (value_ != NULL) value_->::bgs::protocol::Variant::Clear();
+  clear_has_value();
+}
+inline const ::bgs::protocol::Variant& Field::value() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.Field.value)
+  return value_ != NULL ? *value_ : *default_instance_->value_;
+}
+inline ::bgs::protocol::Variant* Field::mutable_value() {
+  set_has_value();
+  if (value_ == NULL) value_ = new ::bgs::protocol::Variant;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.Field.value)
+  return value_;
+}
+inline ::bgs::protocol::Variant* Field::release_value() {
+  clear_has_value();
+  ::bgs::protocol::Variant* temp = value_;
+  value_ = NULL;
+  return temp;
+}
+inline void Field::set_allocated_value(::bgs::protocol::Variant* value) {
+  delete value_;
+  value_ = value;
+  if (value) {
+    set_has_value();
+  } else {
+    clear_has_value();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.Field.value)
+}
+
+// -------------------------------------------------------------------
+
+// FieldOperation
+
+// required .bgs.protocol.presence.v1.Field field = 1;
+inline bool FieldOperation::has_field() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FieldOperation::set_has_field() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FieldOperation::clear_has_field() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FieldOperation::clear_field() {
+  if (field_ != NULL) field_->::bgs::protocol::presence::v1::Field::Clear();
+  clear_has_field();
+}
+inline const ::bgs::protocol::presence::v1::Field& FieldOperation::field() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.FieldOperation.field)
+  return field_ != NULL ? *field_ : *default_instance_->field_;
+}
+inline ::bgs::protocol::presence::v1::Field* FieldOperation::mutable_field() {
+  set_has_field();
+  if (field_ == NULL) field_ = new ::bgs::protocol::presence::v1::Field;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.FieldOperation.field)
+  return field_;
+}
+inline ::bgs::protocol::presence::v1::Field* FieldOperation::release_field() {
+  clear_has_field();
+  ::bgs::protocol::presence::v1::Field* temp = field_;
+  field_ = NULL;
+  return temp;
+}
+inline void FieldOperation::set_allocated_field(::bgs::protocol::presence::v1::Field* field) {
+  delete field_;
+  field_ = field;
+  if (field) {
+    set_has_field();
+  } else {
+    clear_has_field();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.FieldOperation.field)
+}
+
+// optional .bgs.protocol.presence.v1.FieldOperation.OperationType operation = 2 [default = SET];
+inline bool FieldOperation::has_operation() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void FieldOperation::set_has_operation() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void FieldOperation::clear_has_operation() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void FieldOperation::clear_operation() {
+  operation_ = 0;
+  clear_has_operation();
+}
+inline ::bgs::protocol::presence::v1::FieldOperation_OperationType FieldOperation::operation() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.FieldOperation.operation)
+  return static_cast< ::bgs::protocol::presence::v1::FieldOperation_OperationType >(operation_);
+}
+inline void FieldOperation::set_operation(::bgs::protocol::presence::v1::FieldOperation_OperationType value) {
+  assert(::bgs::protocol::presence::v1::FieldOperation_OperationType_IsValid(value));
+  set_has_operation();
+  operation_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.FieldOperation.operation)
+}
+
+// -------------------------------------------------------------------
+
+// ChannelState
+
+// optional .bgs.protocol.EntityId entity_id = 1;
+inline bool ChannelState::has_entity_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ChannelState::set_has_entity_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ChannelState::clear_has_entity_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ChannelState::clear_entity_id() {
+  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id();
+}
+inline const ::bgs::protocol::EntityId& ChannelState::entity_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.ChannelState.entity_id)
+  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
+}
+inline ::bgs::protocol::EntityId* ChannelState::mutable_entity_id() {
+  set_has_entity_id();
+  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.ChannelState.entity_id)
+  return entity_id_;
+}
+inline ::bgs::protocol::EntityId* ChannelState::release_entity_id() {
+  clear_has_entity_id();
+  ::bgs::protocol::EntityId* temp = entity_id_;
+  entity_id_ = NULL;
+  return temp;
+}
+inline void ChannelState::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
+  delete entity_id_;
+  entity_id_ = entity_id;
+  if (entity_id) {
+    set_has_entity_id();
+  } else {
+    clear_has_entity_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.presence.v1.ChannelState.entity_id)
+}
+
+// repeated .bgs.protocol.presence.v1.FieldOperation field_operation = 2;
+inline int ChannelState::field_operation_size() const {
+  return field_operation_.size();
+}
+inline void ChannelState::clear_field_operation() {
+  field_operation_.Clear();
+}
+inline const ::bgs::protocol::presence::v1::FieldOperation& ChannelState::field_operation(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.ChannelState.field_operation)
+  return field_operation_.Get(index);
+}
+inline ::bgs::protocol::presence::v1::FieldOperation* ChannelState::mutable_field_operation(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.presence.v1.ChannelState.field_operation)
+  return field_operation_.Mutable(index);
+}
+inline ::bgs::protocol::presence::v1::FieldOperation* ChannelState::add_field_operation() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.presence.v1.ChannelState.field_operation)
+  return field_operation_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >&
+ChannelState::field_operation() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.presence.v1.ChannelState.field_operation)
+  return field_operation_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::presence::v1::FieldOperation >*
+ChannelState::mutable_field_operation() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.presence.v1.ChannelState.field_operation)
+  return &field_operation_;
+}
+
+// optional bool healing = 3 [default = false];
+inline bool ChannelState::has_healing() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ChannelState::set_has_healing() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ChannelState::clear_has_healing() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ChannelState::clear_healing() {
+  healing_ = false;
+  clear_has_healing();
+}
+inline bool ChannelState::healing() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.presence.v1.ChannelState.healing)
+  return healing_;
+}
+inline void ChannelState::set_healing(bool value) {
+  set_has_healing();
+  healing_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.presence.v1.ChannelState.healing)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace presence
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::bgs::protocol::presence::v1::FieldOperation_OperationType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::presence::v1::FieldOperation_OperationType>() {
+  return ::bgs::protocol::presence::v1::FieldOperation_OperationType_descriptor();
+}
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_presence_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/profanity_filter_config.pb.cc b/src/server/proto/Client/profanity_filter_config.pb.cc
new file mode 100644
index 00000000000..dfd5c1e0fac
--- /dev/null
+++ b/src/server/proto/Client/profanity_filter_config.pb.cc
@@ -0,0 +1,667 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: profanity_filter_config.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "profanity_filter_config.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace profanity {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* WordFilter_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  WordFilter_reflection_ = NULL;
+const ::google::protobuf::Descriptor* WordFilters_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  WordFilters_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_profanity_5ffilter_5fconfig_2eproto() {
+  protobuf_AddDesc_profanity_5ffilter_5fconfig_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "profanity_filter_config.proto");
+  GOOGLE_CHECK(file != NULL);
+  WordFilter_descriptor_ = file->message_type(0);
+  static const int WordFilter_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WordFilter, type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WordFilter, regex_),
+  };
+  WordFilter_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      WordFilter_descriptor_,
+      WordFilter::default_instance_,
+      WordFilter_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WordFilter, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WordFilter, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(WordFilter));
+  WordFilters_descriptor_ = file->message_type(1);
+  static const int WordFilters_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WordFilters, filters_),
+  };
+  WordFilters_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      WordFilters_descriptor_,
+      WordFilters::default_instance_,
+      WordFilters_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WordFilters, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(WordFilters, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(WordFilters));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_profanity_5ffilter_5fconfig_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    WordFilter_descriptor_, &WordFilter::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    WordFilters_descriptor_, &WordFilters::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_profanity_5ffilter_5fconfig_2eproto() {
+  delete WordFilter::default_instance_;
+  delete WordFilter_reflection_;
+  delete WordFilters::default_instance_;
+  delete WordFilters_reflection_;
+}
+
+void protobuf_AddDesc_profanity_5ffilter_5fconfig_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\035profanity_filter_config.proto\022\031bgs.pro"
+    "tocol.profanity.v1\")\n\nWordFilter\022\014\n\004type"
+    "\030\001 \002(\t\022\r\n\005regex\030\002 \002(\t\"E\n\013WordFilters\0226\n\007"
+    "filters\030\001 \003(\0132%.bgs.protocol.profanity.v"
+    "1.WordFilterB\002H\001", 176);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "profanity_filter_config.proto", &protobuf_RegisterTypes);
+  WordFilter::default_instance_ = new WordFilter();
+  WordFilters::default_instance_ = new WordFilters();
+  WordFilter::default_instance_->InitAsDefaultInstance();
+  WordFilters::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_profanity_5ffilter_5fconfig_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_profanity_5ffilter_5fconfig_2eproto {
+  StaticDescriptorInitializer_profanity_5ffilter_5fconfig_2eproto() {
+    protobuf_AddDesc_profanity_5ffilter_5fconfig_2eproto();
+  }
+} static_descriptor_initializer_profanity_5ffilter_5fconfig_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int WordFilter::kTypeFieldNumber;
+const int WordFilter::kRegexFieldNumber;
+#endif  // !_MSC_VER
+
+WordFilter::WordFilter()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.profanity.v1.WordFilter)
+}
+
+void WordFilter::InitAsDefaultInstance() {
+}
+
+WordFilter::WordFilter(const WordFilter& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.profanity.v1.WordFilter)
+}
+
+void WordFilter::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  regex_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+WordFilter::~WordFilter() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.profanity.v1.WordFilter)
+  SharedDtor();
+}
+
+void WordFilter::SharedDtor() {
+  if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete type_;
+  }
+  if (regex_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete regex_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void WordFilter::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* WordFilter::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return WordFilter_descriptor_;
+}
+
+const WordFilter& WordFilter::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_profanity_5ffilter_5fconfig_2eproto();
+  return *default_instance_;
+}
+
+WordFilter* WordFilter::default_instance_ = NULL;
+
+WordFilter* WordFilter::New() const {
+  return new WordFilter;
+}
+
+void WordFilter::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_type()) {
+      if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        type_->clear();
+      }
+    }
+    if (has_regex()) {
+      if (regex_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        regex_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool WordFilter::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.profanity.v1.WordFilter)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required string type = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_type()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->type().data(), this->type().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "type");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_regex;
+        break;
+      }
+
+      // required string regex = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_regex:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_regex()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->regex().data(), this->regex().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "regex");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.profanity.v1.WordFilter)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.profanity.v1.WordFilter)
+  return false;
+#undef DO_
+}
+
+void WordFilter::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.profanity.v1.WordFilter)
+  // required string type = 1;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->type().data(), this->type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "type");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->type(), output);
+  }
+
+  // required string regex = 2;
+  if (has_regex()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->regex().data(), this->regex().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "regex");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->regex(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.profanity.v1.WordFilter)
+}
+
+::google::protobuf::uint8* WordFilter::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.profanity.v1.WordFilter)
+  // required string type = 1;
+  if (has_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->type().data(), this->type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "type");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->type(), target);
+  }
+
+  // required string regex = 2;
+  if (has_regex()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->regex().data(), this->regex().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "regex");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->regex(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.profanity.v1.WordFilter)
+  return target;
+}
+
+int WordFilter::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required string type = 1;
+    if (has_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->type());
+    }
+
+    // required string regex = 2;
+    if (has_regex()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->regex());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void WordFilter::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const WordFilter* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const WordFilter*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void WordFilter::MergeFrom(const WordFilter& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_type()) {
+      set_type(from.type());
+    }
+    if (from.has_regex()) {
+      set_regex(from.regex());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void WordFilter::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void WordFilter::CopyFrom(const WordFilter& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool WordFilter::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  return true;
+}
+
+void WordFilter::Swap(WordFilter* other) {
+  if (other != this) {
+    std::swap(type_, other->type_);
+    std::swap(regex_, other->regex_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata WordFilter::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = WordFilter_descriptor_;
+  metadata.reflection = WordFilter_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int WordFilters::kFiltersFieldNumber;
+#endif  // !_MSC_VER
+
+WordFilters::WordFilters()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.profanity.v1.WordFilters)
+}
+
+void WordFilters::InitAsDefaultInstance() {
+}
+
+WordFilters::WordFilters(const WordFilters& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.profanity.v1.WordFilters)
+}
+
+void WordFilters::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+WordFilters::~WordFilters() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.profanity.v1.WordFilters)
+  SharedDtor();
+}
+
+void WordFilters::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void WordFilters::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* WordFilters::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return WordFilters_descriptor_;
+}
+
+const WordFilters& WordFilters::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_profanity_5ffilter_5fconfig_2eproto();
+  return *default_instance_;
+}
+
+WordFilters* WordFilters::default_instance_ = NULL;
+
+WordFilters* WordFilters::New() const {
+  return new WordFilters;
+}
+
+void WordFilters::Clear() {
+  filters_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool WordFilters::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.profanity.v1.WordFilters)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.profanity.v1.WordFilter filters = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_filters:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_filters()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_filters;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.profanity.v1.WordFilters)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.profanity.v1.WordFilters)
+  return false;
+#undef DO_
+}
+
+void WordFilters::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.profanity.v1.WordFilters)
+  // repeated .bgs.protocol.profanity.v1.WordFilter filters = 1;
+  for (int i = 0; i < this->filters_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->filters(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.profanity.v1.WordFilters)
+}
+
+::google::protobuf::uint8* WordFilters::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.profanity.v1.WordFilters)
+  // repeated .bgs.protocol.profanity.v1.WordFilter filters = 1;
+  for (int i = 0; i < this->filters_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->filters(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.profanity.v1.WordFilters)
+  return target;
+}
+
+int WordFilters::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.profanity.v1.WordFilter filters = 1;
+  total_size += 1 * this->filters_size();
+  for (int i = 0; i < this->filters_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->filters(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void WordFilters::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const WordFilters* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const WordFilters*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void WordFilters::MergeFrom(const WordFilters& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  filters_.MergeFrom(from.filters_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void WordFilters::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void WordFilters::CopyFrom(const WordFilters& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool WordFilters::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->filters())) return false;
+  return true;
+}
+
+void WordFilters::Swap(WordFilters* other) {
+  if (other != this) {
+    filters_.Swap(&other->filters_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata WordFilters::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = WordFilters_descriptor_;
+  metadata.reflection = WordFilters_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace profanity
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/profanity_filter_config.pb.h b/src/server/proto/Client/profanity_filter_config.pb.h
new file mode 100644
index 00000000000..ff3788f2c49
--- /dev/null
+++ b/src/server/proto/Client/profanity_filter_config.pb.h
@@ -0,0 +1,439 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: profanity_filter_config.proto
+
+#ifndef PROTOBUF_profanity_5ffilter_5fconfig_2eproto__INCLUDED
+#define PROTOBUF_profanity_5ffilter_5fconfig_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 "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace profanity {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_profanity_5ffilter_5fconfig_2eproto();
+void protobuf_AssignDesc_profanity_5ffilter_5fconfig_2eproto();
+void protobuf_ShutdownFile_profanity_5ffilter_5fconfig_2eproto();
+
+class WordFilter;
+class WordFilters;
+
+// ===================================================================
+
+class TC_SHARED_API WordFilter : public ::google::protobuf::Message {
+ public:
+  WordFilter();
+  virtual ~WordFilter();
+
+  WordFilter(const WordFilter& from);
+
+  inline WordFilter& operator=(const WordFilter& 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 WordFilter& default_instance();
+
+  void Swap(WordFilter* other);
+
+  // implements Message ----------------------------------------------
+
+  WordFilter* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const WordFilter& from);
+  void MergeFrom(const WordFilter& 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 string type = 1;
+  inline bool has_type() const;
+  inline void clear_type();
+  static const int kTypeFieldNumber = 1;
+  inline const ::std::string& type() const;
+  inline void set_type(const ::std::string& value);
+  inline void set_type(const char* value);
+  inline void set_type(const char* value, size_t size);
+  inline ::std::string* mutable_type();
+  inline ::std::string* release_type();
+  inline void set_allocated_type(::std::string* type);
+
+  // required string regex = 2;
+  inline bool has_regex() const;
+  inline void clear_regex();
+  static const int kRegexFieldNumber = 2;
+  inline const ::std::string& regex() const;
+  inline void set_regex(const ::std::string& value);
+  inline void set_regex(const char* value);
+  inline void set_regex(const char* value, size_t size);
+  inline ::std::string* mutable_regex();
+  inline ::std::string* release_regex();
+  inline void set_allocated_regex(::std::string* regex);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.profanity.v1.WordFilter)
+ private:
+  inline void set_has_type();
+  inline void clear_has_type();
+  inline void set_has_regex();
+  inline void clear_has_regex();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* type_;
+  ::std::string* regex_;
+  friend void TC_SHARED_API protobuf_AddDesc_profanity_5ffilter_5fconfig_2eproto();
+  friend void protobuf_AssignDesc_profanity_5ffilter_5fconfig_2eproto();
+  friend void protobuf_ShutdownFile_profanity_5ffilter_5fconfig_2eproto();
+
+  void InitAsDefaultInstance();
+  static WordFilter* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API WordFilters : public ::google::protobuf::Message {
+ public:
+  WordFilters();
+  virtual ~WordFilters();
+
+  WordFilters(const WordFilters& from);
+
+  inline WordFilters& operator=(const WordFilters& 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 WordFilters& default_instance();
+
+  void Swap(WordFilters* other);
+
+  // implements Message ----------------------------------------------
+
+  WordFilters* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const WordFilters& from);
+  void MergeFrom(const WordFilters& 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.profanity.v1.WordFilter filters = 1;
+  inline int filters_size() const;
+  inline void clear_filters();
+  static const int kFiltersFieldNumber = 1;
+  inline const ::bgs::protocol::profanity::v1::WordFilter& filters(int index) const;
+  inline ::bgs::protocol::profanity::v1::WordFilter* mutable_filters(int index);
+  inline ::bgs::protocol::profanity::v1::WordFilter* add_filters();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::profanity::v1::WordFilter >&
+      filters() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::profanity::v1::WordFilter >*
+      mutable_filters();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.profanity.v1.WordFilters)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::profanity::v1::WordFilter > filters_;
+  friend void TC_SHARED_API protobuf_AddDesc_profanity_5ffilter_5fconfig_2eproto();
+  friend void protobuf_AssignDesc_profanity_5ffilter_5fconfig_2eproto();
+  friend void protobuf_ShutdownFile_profanity_5ffilter_5fconfig_2eproto();
+
+  void InitAsDefaultInstance();
+  static WordFilters* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// WordFilter
+
+// required string type = 1;
+inline bool WordFilter::has_type() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void WordFilter::set_has_type() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void WordFilter::clear_has_type() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void WordFilter::clear_type() {
+  if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_->clear();
+  }
+  clear_has_type();
+}
+inline const ::std::string& WordFilter::type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.profanity.v1.WordFilter.type)
+  return *type_;
+}
+inline void WordFilter::set_type(const ::std::string& value) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_ = new ::std::string;
+  }
+  type_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.profanity.v1.WordFilter.type)
+}
+inline void WordFilter::set_type(const char* value) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_ = new ::std::string;
+  }
+  type_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.profanity.v1.WordFilter.type)
+}
+inline void WordFilter::set_type(const char* value, size_t size) {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_ = new ::std::string;
+  }
+  type_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.profanity.v1.WordFilter.type)
+}
+inline ::std::string* WordFilter::mutable_type() {
+  set_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    type_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.profanity.v1.WordFilter.type)
+  return type_;
+}
+inline ::std::string* WordFilter::release_type() {
+  clear_has_type();
+  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = type_;
+    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void WordFilter::set_allocated_type(::std::string* type) {
+  if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete type_;
+  }
+  if (type) {
+    set_has_type();
+    type_ = type;
+  } else {
+    clear_has_type();
+    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.profanity.v1.WordFilter.type)
+}
+
+// required string regex = 2;
+inline bool WordFilter::has_regex() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void WordFilter::set_has_regex() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void WordFilter::clear_has_regex() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void WordFilter::clear_regex() {
+  if (regex_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    regex_->clear();
+  }
+  clear_has_regex();
+}
+inline const ::std::string& WordFilter::regex() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.profanity.v1.WordFilter.regex)
+  return *regex_;
+}
+inline void WordFilter::set_regex(const ::std::string& value) {
+  set_has_regex();
+  if (regex_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    regex_ = new ::std::string;
+  }
+  regex_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.profanity.v1.WordFilter.regex)
+}
+inline void WordFilter::set_regex(const char* value) {
+  set_has_regex();
+  if (regex_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    regex_ = new ::std::string;
+  }
+  regex_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.profanity.v1.WordFilter.regex)
+}
+inline void WordFilter::set_regex(const char* value, size_t size) {
+  set_has_regex();
+  if (regex_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    regex_ = new ::std::string;
+  }
+  regex_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.profanity.v1.WordFilter.regex)
+}
+inline ::std::string* WordFilter::mutable_regex() {
+  set_has_regex();
+  if (regex_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    regex_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.profanity.v1.WordFilter.regex)
+  return regex_;
+}
+inline ::std::string* WordFilter::release_regex() {
+  clear_has_regex();
+  if (regex_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = regex_;
+    regex_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void WordFilter::set_allocated_regex(::std::string* regex) {
+  if (regex_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete regex_;
+  }
+  if (regex) {
+    set_has_regex();
+    regex_ = regex;
+  } else {
+    clear_has_regex();
+    regex_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.profanity.v1.WordFilter.regex)
+}
+
+// -------------------------------------------------------------------
+
+// WordFilters
+
+// repeated .bgs.protocol.profanity.v1.WordFilter filters = 1;
+inline int WordFilters::filters_size() const {
+  return filters_.size();
+}
+inline void WordFilters::clear_filters() {
+  filters_.Clear();
+}
+inline const ::bgs::protocol::profanity::v1::WordFilter& WordFilters::filters(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.profanity.v1.WordFilters.filters)
+  return filters_.Get(index);
+}
+inline ::bgs::protocol::profanity::v1::WordFilter* WordFilters::mutable_filters(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.profanity.v1.WordFilters.filters)
+  return filters_.Mutable(index);
+}
+inline ::bgs::protocol::profanity::v1::WordFilter* WordFilters::add_filters() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.profanity.v1.WordFilters.filters)
+  return filters_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::profanity::v1::WordFilter >&
+WordFilters::filters() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.profanity.v1.WordFilters.filters)
+  return filters_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::profanity::v1::WordFilter >*
+WordFilters::mutable_filters() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.profanity.v1.WordFilters.filters)
+  return &filters_;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace profanity
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_profanity_5ffilter_5fconfig_2eproto__INCLUDED
diff --git a/src/server/proto/Client/report_service.pb.cc b/src/server/proto/Client/report_service.pb.cc
new file mode 100644
index 00000000000..216aeb23a2f
--- /dev/null
+++ b/src/server/proto/Client/report_service.pb.cc
@@ -0,0 +1,912 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: report_service.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "report_service.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+#include "BattlenetRpcErrorCodes.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace report {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* Report_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Report_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SendReportRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SendReportRequest_reflection_ = NULL;
+const ::google::protobuf::ServiceDescriptor* ReportService_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_report_5fservice_2eproto() {
+  protobuf_AddDesc_report_5fservice_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "report_service.proto");
+  GOOGLE_CHECK(file != NULL);
+  Report_descriptor_ = file->message_type(0);
+  static const int Report_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Report, report_type_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Report, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Report, report_qos_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Report, reporting_account_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Report, reporting_game_account_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Report, report_timestamp_),
+  };
+  Report_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Report_descriptor_,
+      Report::default_instance_,
+      Report_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Report, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Report, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Report));
+  SendReportRequest_descriptor_ = file->message_type(1);
+  static const int SendReportRequest_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendReportRequest, report_),
+  };
+  SendReportRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SendReportRequest_descriptor_,
+      SendReportRequest::default_instance_,
+      SendReportRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendReportRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SendReportRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SendReportRequest));
+  ReportService_descriptor_ = file->service(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_report_5fservice_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Report_descriptor_, &Report::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SendReportRequest_descriptor_, &SendReportRequest::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_report_5fservice_2eproto() {
+  delete Report::default_instance_;
+  delete Report_reflection_;
+  delete SendReportRequest::default_instance_;
+  delete SendReportRequest_reflection_;
+}
+
+void protobuf_AddDesc_report_5fservice_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\024report_service.proto\022\026bgs.protocol.rep"
+    "ort.v1\032\025attribute_types.proto\032\022entity_ty"
+    "pes.proto\032\017rpc_types.proto\"\345\001\n\006Report\022\023\n"
+    "\013report_type\030\001 \002(\t\022*\n\tattribute\030\002 \003(\0132\027."
+    "bgs.protocol.Attribute\022\025\n\nreport_qos\030\003 \001"
+    "(\005:\0010\0221\n\021reporting_account\030\004 \001(\0132\026.bgs.p"
+    "rotocol.EntityId\0226\n\026reporting_game_accou"
+    "nt\030\005 \001(\0132\026.bgs.protocol.EntityId\022\030\n\020repo"
+    "rt_timestamp\030\006 \001(\006\"C\n\021SendReportRequest\022"
+    ".\n\006report\030\001 \002(\0132\036.bgs.protocol.report.v1"
+    ".Report2\213\001\n\rReportService\022S\n\nSendReport\022"
+    ").bgs.protocol.report.v1.SendReportReque"
+    "st\032\024.bgs.protocol.NoData\"\004\200\265\030\001\032%\312>\"bnet."
+    "protocol.report.ReportServiceB\005H\001\200\001\000", 556);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "report_service.proto", &protobuf_RegisterTypes);
+  Report::default_instance_ = new Report();
+  SendReportRequest::default_instance_ = new SendReportRequest();
+  Report::default_instance_->InitAsDefaultInstance();
+  SendReportRequest::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_report_5fservice_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_report_5fservice_2eproto {
+  StaticDescriptorInitializer_report_5fservice_2eproto() {
+    protobuf_AddDesc_report_5fservice_2eproto();
+  }
+} static_descriptor_initializer_report_5fservice_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Report::kReportTypeFieldNumber;
+const int Report::kAttributeFieldNumber;
+const int Report::kReportQosFieldNumber;
+const int Report::kReportingAccountFieldNumber;
+const int Report::kReportingGameAccountFieldNumber;
+const int Report::kReportTimestampFieldNumber;
+#endif  // !_MSC_VER
+
+Report::Report()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.report.v1.Report)
+}
+
+void Report::InitAsDefaultInstance() {
+  reporting_account_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  reporting_game_account_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+Report::Report(const Report& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.report.v1.Report)
+}
+
+void Report::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  report_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  report_qos_ = 0;
+  reporting_account_ = NULL;
+  reporting_game_account_ = NULL;
+  report_timestamp_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Report::~Report() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.report.v1.Report)
+  SharedDtor();
+}
+
+void Report::SharedDtor() {
+  if (report_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete report_type_;
+  }
+  if (this != default_instance_) {
+    delete reporting_account_;
+    delete reporting_game_account_;
+  }
+}
+
+void Report::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Report::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Report_descriptor_;
+}
+
+const Report& Report::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_report_5fservice_2eproto();
+  return *default_instance_;
+}
+
+Report* Report::default_instance_ = NULL;
+
+Report* Report::New() const {
+  return new Report;
+}
+
+void Report::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<Report*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 61) {
+    ZR_(report_timestamp_, report_qos_);
+    if (has_report_type()) {
+      if (report_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        report_type_->clear();
+      }
+    }
+    if (has_reporting_account()) {
+      if (reporting_account_ != NULL) reporting_account_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_reporting_game_account()) {
+      if (reporting_game_account_ != NULL) reporting_game_account_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  attribute_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Report::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.report.v1.Report)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required string report_type = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_report_type()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->report_type().data(), this->report_type().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "report_type");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.Attribute attribute = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_attribute;
+        if (input->ExpectTag(24)) goto parse_report_qos;
+        break;
+      }
+
+      // optional int32 report_qos = 3 [default = 0];
+      case 3: {
+        if (tag == 24) {
+         parse_report_qos:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
+                 input, &report_qos_)));
+          set_has_report_qos();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_reporting_account;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId reporting_account = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_reporting_account:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_reporting_account()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_reporting_game_account;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId reporting_game_account = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_reporting_game_account:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_reporting_game_account()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(49)) goto parse_report_timestamp;
+        break;
+      }
+
+      // optional fixed64 report_timestamp = 6;
+      case 6: {
+        if (tag == 49) {
+         parse_report_timestamp:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &report_timestamp_)));
+          set_has_report_timestamp();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.report.v1.Report)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.report.v1.Report)
+  return false;
+#undef DO_
+}
+
+void Report::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.report.v1.Report)
+  // required string report_type = 1;
+  if (has_report_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->report_type().data(), this->report_type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "report_type");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->report_type(), output);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->attribute(i), output);
+  }
+
+  // optional int32 report_qos = 3 [default = 0];
+  if (has_report_qos()) {
+    ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->report_qos(), output);
+  }
+
+  // optional .bgs.protocol.EntityId reporting_account = 4;
+  if (has_reporting_account()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->reporting_account(), output);
+  }
+
+  // optional .bgs.protocol.EntityId reporting_game_account = 5;
+  if (has_reporting_game_account()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->reporting_game_account(), output);
+  }
+
+  // optional fixed64 report_timestamp = 6;
+  if (has_report_timestamp()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(6, this->report_timestamp(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.report.v1.Report)
+}
+
+::google::protobuf::uint8* Report::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.report.v1.Report)
+  // required string report_type = 1;
+  if (has_report_type()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->report_type().data(), this->report_type().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "report_type");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->report_type(), target);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 2;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->attribute(i), target);
+  }
+
+  // optional int32 report_qos = 3 [default = 0];
+  if (has_report_qos()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->report_qos(), target);
+  }
+
+  // optional .bgs.protocol.EntityId reporting_account = 4;
+  if (has_reporting_account()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->reporting_account(), target);
+  }
+
+  // optional .bgs.protocol.EntityId reporting_game_account = 5;
+  if (has_reporting_game_account()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->reporting_game_account(), target);
+  }
+
+  // optional fixed64 report_timestamp = 6;
+  if (has_report_timestamp()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(6, this->report_timestamp(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.report.v1.Report)
+  return target;
+}
+
+int Report::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required string report_type = 1;
+    if (has_report_type()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->report_type());
+    }
+
+    // optional int32 report_qos = 3 [default = 0];
+    if (has_report_qos()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(
+          this->report_qos());
+    }
+
+    // optional .bgs.protocol.EntityId reporting_account = 4;
+    if (has_reporting_account()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->reporting_account());
+    }
+
+    // optional .bgs.protocol.EntityId reporting_game_account = 5;
+    if (has_reporting_game_account()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->reporting_game_account());
+    }
+
+    // optional fixed64 report_timestamp = 6;
+    if (has_report_timestamp()) {
+      total_size += 1 + 8;
+    }
+
+  }
+  // repeated .bgs.protocol.Attribute attribute = 2;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Report::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Report* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Report*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Report::MergeFrom(const Report& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attribute_.MergeFrom(from.attribute_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_report_type()) {
+      set_report_type(from.report_type());
+    }
+    if (from.has_report_qos()) {
+      set_report_qos(from.report_qos());
+    }
+    if (from.has_reporting_account()) {
+      mutable_reporting_account()->::bgs::protocol::EntityId::MergeFrom(from.reporting_account());
+    }
+    if (from.has_reporting_game_account()) {
+      mutable_reporting_game_account()->::bgs::protocol::EntityId::MergeFrom(from.reporting_game_account());
+    }
+    if (from.has_report_timestamp()) {
+      set_report_timestamp(from.report_timestamp());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Report::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Report::CopyFrom(const Report& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Report::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
+  if (has_reporting_account()) {
+    if (!this->reporting_account().IsInitialized()) return false;
+  }
+  if (has_reporting_game_account()) {
+    if (!this->reporting_game_account().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void Report::Swap(Report* other) {
+  if (other != this) {
+    std::swap(report_type_, other->report_type_);
+    attribute_.Swap(&other->attribute_);
+    std::swap(report_qos_, other->report_qos_);
+    std::swap(reporting_account_, other->reporting_account_);
+    std::swap(reporting_game_account_, other->reporting_game_account_);
+    std::swap(report_timestamp_, other->report_timestamp_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Report::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Report_descriptor_;
+  metadata.reflection = Report_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SendReportRequest::kReportFieldNumber;
+#endif  // !_MSC_VER
+
+SendReportRequest::SendReportRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.report.v1.SendReportRequest)
+}
+
+void SendReportRequest::InitAsDefaultInstance() {
+  report_ = const_cast< ::bgs::protocol::report::v1::Report*>(&::bgs::protocol::report::v1::Report::default_instance());
+}
+
+SendReportRequest::SendReportRequest(const SendReportRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.report.v1.SendReportRequest)
+}
+
+void SendReportRequest::SharedCtor() {
+  _cached_size_ = 0;
+  report_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SendReportRequest::~SendReportRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.report.v1.SendReportRequest)
+  SharedDtor();
+}
+
+void SendReportRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete report_;
+  }
+}
+
+void SendReportRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SendReportRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SendReportRequest_descriptor_;
+}
+
+const SendReportRequest& SendReportRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_report_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SendReportRequest* SendReportRequest::default_instance_ = NULL;
+
+SendReportRequest* SendReportRequest::New() const {
+  return new SendReportRequest;
+}
+
+void SendReportRequest::Clear() {
+  if (has_report()) {
+    if (report_ != NULL) report_->::bgs::protocol::report::v1::Report::Clear();
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SendReportRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.report.v1.SendReportRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.report.v1.Report report = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_report()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.report.v1.SendReportRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.report.v1.SendReportRequest)
+  return false;
+#undef DO_
+}
+
+void SendReportRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.report.v1.SendReportRequest)
+  // required .bgs.protocol.report.v1.Report report = 1;
+  if (has_report()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->report(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.report.v1.SendReportRequest)
+}
+
+::google::protobuf::uint8* SendReportRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.report.v1.SendReportRequest)
+  // required .bgs.protocol.report.v1.Report report = 1;
+  if (has_report()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->report(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.report.v1.SendReportRequest)
+  return target;
+}
+
+int SendReportRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.report.v1.Report report = 1;
+    if (has_report()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->report());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SendReportRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SendReportRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SendReportRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SendReportRequest::MergeFrom(const SendReportRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_report()) {
+      mutable_report()->::bgs::protocol::report::v1::Report::MergeFrom(from.report());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SendReportRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SendReportRequest::CopyFrom(const SendReportRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SendReportRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_report()) {
+    if (!this->report().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SendReportRequest::Swap(SendReportRequest* other) {
+  if (other != this) {
+    std::swap(report_, other->report_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SendReportRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SendReportRequest_descriptor_;
+  metadata.reflection = SendReportRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* ReportService::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ReportService_descriptor_;
+}
+
+void ReportService::SendReport(::bgs::protocol::report::v1::SendReportRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ReportService.SendReport(bgs.protocol.report.v1.SendReportRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ReportService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::report::v1::SendReportRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ReportService.SendReport server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleSendReport(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ReportService.SendReport(bgs.protocol.report.v1.SendReportRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 1, token, &response);
+      else
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 ReportService::HandleSendReport(::bgs::protocol::report::v1::SendReportRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ReportService.SendReport({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace report
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/report_service.pb.h b/src/server/proto/Client/report_service.pb.h
new file mode 100644
index 00000000000..c078aa079f1
--- /dev/null
+++ b/src/server/proto/Client/report_service.pb.h
@@ -0,0 +1,608 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: report_service.proto
+
+#ifndef PROTOBUF_report_5fservice_2eproto__INCLUDED
+#define PROTOBUF_report_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 "attribute_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 report {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_report_5fservice_2eproto();
+void protobuf_AssignDesc_report_5fservice_2eproto();
+void protobuf_ShutdownFile_report_5fservice_2eproto();
+
+class Report;
+class SendReportRequest;
+
+// ===================================================================
+
+class TC_SHARED_API Report : public ::google::protobuf::Message {
+ public:
+  Report();
+  virtual ~Report();
+
+  Report(const Report& from);
+
+  inline Report& operator=(const Report& 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 Report& default_instance();
+
+  void Swap(Report* other);
+
+  // implements Message ----------------------------------------------
+
+  Report* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Report& from);
+  void MergeFrom(const Report& 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 string report_type = 1;
+  inline bool has_report_type() const;
+  inline void clear_report_type();
+  static const int kReportTypeFieldNumber = 1;
+  inline const ::std::string& report_type() const;
+  inline void set_report_type(const ::std::string& value);
+  inline void set_report_type(const char* value);
+  inline void set_report_type(const char* value, size_t size);
+  inline ::std::string* mutable_report_type();
+  inline ::std::string* release_report_type();
+  inline void set_allocated_report_type(::std::string* report_type);
+
+  // repeated .bgs.protocol.Attribute attribute = 2;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 2;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
+  // optional int32 report_qos = 3 [default = 0];
+  inline bool has_report_qos() const;
+  inline void clear_report_qos();
+  static const int kReportQosFieldNumber = 3;
+  inline ::google::protobuf::int32 report_qos() const;
+  inline void set_report_qos(::google::protobuf::int32 value);
+
+  // optional .bgs.protocol.EntityId reporting_account = 4;
+  inline bool has_reporting_account() const;
+  inline void clear_reporting_account();
+  static const int kReportingAccountFieldNumber = 4;
+  inline const ::bgs::protocol::EntityId& reporting_account() const;
+  inline ::bgs::protocol::EntityId* mutable_reporting_account();
+  inline ::bgs::protocol::EntityId* release_reporting_account();
+  inline void set_allocated_reporting_account(::bgs::protocol::EntityId* reporting_account);
+
+  // optional .bgs.protocol.EntityId reporting_game_account = 5;
+  inline bool has_reporting_game_account() const;
+  inline void clear_reporting_game_account();
+  static const int kReportingGameAccountFieldNumber = 5;
+  inline const ::bgs::protocol::EntityId& reporting_game_account() const;
+  inline ::bgs::protocol::EntityId* mutable_reporting_game_account();
+  inline ::bgs::protocol::EntityId* release_reporting_game_account();
+  inline void set_allocated_reporting_game_account(::bgs::protocol::EntityId* reporting_game_account);
+
+  // optional fixed64 report_timestamp = 6;
+  inline bool has_report_timestamp() const;
+  inline void clear_report_timestamp();
+  static const int kReportTimestampFieldNumber = 6;
+  inline ::google::protobuf::uint64 report_timestamp() const;
+  inline void set_report_timestamp(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.report.v1.Report)
+ private:
+  inline void set_has_report_type();
+  inline void clear_has_report_type();
+  inline void set_has_report_qos();
+  inline void clear_has_report_qos();
+  inline void set_has_reporting_account();
+  inline void clear_has_reporting_account();
+  inline void set_has_reporting_game_account();
+  inline void clear_has_reporting_game_account();
+  inline void set_has_report_timestamp();
+  inline void clear_has_report_timestamp();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* report_type_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
+  ::bgs::protocol::EntityId* reporting_account_;
+  ::bgs::protocol::EntityId* reporting_game_account_;
+  ::google::protobuf::uint64 report_timestamp_;
+  ::google::protobuf::int32 report_qos_;
+  friend void TC_SHARED_API protobuf_AddDesc_report_5fservice_2eproto();
+  friend void protobuf_AssignDesc_report_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_report_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static Report* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API SendReportRequest : public ::google::protobuf::Message {
+ public:
+  SendReportRequest();
+  virtual ~SendReportRequest();
+
+  SendReportRequest(const SendReportRequest& from);
+
+  inline SendReportRequest& operator=(const SendReportRequest& 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 SendReportRequest& default_instance();
+
+  void Swap(SendReportRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SendReportRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SendReportRequest& from);
+  void MergeFrom(const SendReportRequest& 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.report.v1.Report report = 1;
+  inline bool has_report() const;
+  inline void clear_report();
+  static const int kReportFieldNumber = 1;
+  inline const ::bgs::protocol::report::v1::Report& report() const;
+  inline ::bgs::protocol::report::v1::Report* mutable_report();
+  inline ::bgs::protocol::report::v1::Report* release_report();
+  inline void set_allocated_report(::bgs::protocol::report::v1::Report* report);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.report.v1.SendReportRequest)
+ private:
+  inline void set_has_report();
+  inline void clear_has_report();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::report::v1::Report* report_;
+  friend void TC_SHARED_API protobuf_AddDesc_report_5fservice_2eproto();
+  friend void protobuf_AssignDesc_report_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_report_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SendReportRequest* default_instance_;
+};
+// ===================================================================
+
+class TC_SHARED_API ReportService : public ServiceBase
+{
+ public:
+
+  template<typename HashSelector>
+  explicit ReportService(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  typedef std::integral_constant<uint32, 0x7CAF61C9u> OriginalHash;
+  typedef std::integral_constant<uint32, 0x724F5F47u> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void SendReport(::bgs::protocol::report::v1::SendReportRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleSendReport(::bgs::protocol::report::v1::SendReportRequest const* request, ::bgs::protocol::NoData* response);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ReportService);
+};
+
+// ===================================================================
+
+
+// ===================================================================
+
+// Report
+
+// required string report_type = 1;
+inline bool Report::has_report_type() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Report::set_has_report_type() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Report::clear_has_report_type() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Report::clear_report_type() {
+  if (report_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    report_type_->clear();
+  }
+  clear_has_report_type();
+}
+inline const ::std::string& Report::report_type() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.report_type)
+  return *report_type_;
+}
+inline void Report::set_report_type(const ::std::string& value) {
+  set_has_report_type();
+  if (report_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    report_type_ = new ::std::string;
+  }
+  report_type_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.Report.report_type)
+}
+inline void Report::set_report_type(const char* value) {
+  set_has_report_type();
+  if (report_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    report_type_ = new ::std::string;
+  }
+  report_type_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.report.v1.Report.report_type)
+}
+inline void Report::set_report_type(const char* value, size_t size) {
+  set_has_report_type();
+  if (report_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    report_type_ = new ::std::string;
+  }
+  report_type_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.report.v1.Report.report_type)
+}
+inline ::std::string* Report::mutable_report_type() {
+  set_has_report_type();
+  if (report_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    report_type_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.Report.report_type)
+  return report_type_;
+}
+inline ::std::string* Report::release_report_type() {
+  clear_has_report_type();
+  if (report_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = report_type_;
+    report_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Report::set_allocated_report_type(::std::string* report_type) {
+  if (report_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete report_type_;
+  }
+  if (report_type) {
+    set_has_report_type();
+    report_type_ = report_type;
+  } else {
+    clear_has_report_type();
+    report_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.Report.report_type)
+}
+
+// repeated .bgs.protocol.Attribute attribute = 2;
+inline int Report::attribute_size() const {
+  return attribute_.size();
+}
+inline void Report::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::Attribute& Report::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::Attribute* Report::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.Report.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* Report::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.report.v1.Report.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+Report::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.report.v1.Report.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+Report::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.report.v1.Report.attribute)
+  return &attribute_;
+}
+
+// optional int32 report_qos = 3 [default = 0];
+inline bool Report::has_report_qos() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Report::set_has_report_qos() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Report::clear_has_report_qos() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Report::clear_report_qos() {
+  report_qos_ = 0;
+  clear_has_report_qos();
+}
+inline ::google::protobuf::int32 Report::report_qos() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.report_qos)
+  return report_qos_;
+}
+inline void Report::set_report_qos(::google::protobuf::int32 value) {
+  set_has_report_qos();
+  report_qos_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.Report.report_qos)
+}
+
+// optional .bgs.protocol.EntityId reporting_account = 4;
+inline bool Report::has_reporting_account() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Report::set_has_reporting_account() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Report::clear_has_reporting_account() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Report::clear_reporting_account() {
+  if (reporting_account_ != NULL) reporting_account_->::bgs::protocol::EntityId::Clear();
+  clear_has_reporting_account();
+}
+inline const ::bgs::protocol::EntityId& Report::reporting_account() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.reporting_account)
+  return reporting_account_ != NULL ? *reporting_account_ : *default_instance_->reporting_account_;
+}
+inline ::bgs::protocol::EntityId* Report::mutable_reporting_account() {
+  set_has_reporting_account();
+  if (reporting_account_ == NULL) reporting_account_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.Report.reporting_account)
+  return reporting_account_;
+}
+inline ::bgs::protocol::EntityId* Report::release_reporting_account() {
+  clear_has_reporting_account();
+  ::bgs::protocol::EntityId* temp = reporting_account_;
+  reporting_account_ = NULL;
+  return temp;
+}
+inline void Report::set_allocated_reporting_account(::bgs::protocol::EntityId* reporting_account) {
+  delete reporting_account_;
+  reporting_account_ = reporting_account;
+  if (reporting_account) {
+    set_has_reporting_account();
+  } else {
+    clear_has_reporting_account();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.Report.reporting_account)
+}
+
+// optional .bgs.protocol.EntityId reporting_game_account = 5;
+inline bool Report::has_reporting_game_account() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void Report::set_has_reporting_game_account() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void Report::clear_has_reporting_game_account() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void Report::clear_reporting_game_account() {
+  if (reporting_game_account_ != NULL) reporting_game_account_->::bgs::protocol::EntityId::Clear();
+  clear_has_reporting_game_account();
+}
+inline const ::bgs::protocol::EntityId& Report::reporting_game_account() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.reporting_game_account)
+  return reporting_game_account_ != NULL ? *reporting_game_account_ : *default_instance_->reporting_game_account_;
+}
+inline ::bgs::protocol::EntityId* Report::mutable_reporting_game_account() {
+  set_has_reporting_game_account();
+  if (reporting_game_account_ == NULL) reporting_game_account_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.Report.reporting_game_account)
+  return reporting_game_account_;
+}
+inline ::bgs::protocol::EntityId* Report::release_reporting_game_account() {
+  clear_has_reporting_game_account();
+  ::bgs::protocol::EntityId* temp = reporting_game_account_;
+  reporting_game_account_ = NULL;
+  return temp;
+}
+inline void Report::set_allocated_reporting_game_account(::bgs::protocol::EntityId* reporting_game_account) {
+  delete reporting_game_account_;
+  reporting_game_account_ = reporting_game_account;
+  if (reporting_game_account) {
+    set_has_reporting_game_account();
+  } else {
+    clear_has_reporting_game_account();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.Report.reporting_game_account)
+}
+
+// optional fixed64 report_timestamp = 6;
+inline bool Report::has_report_timestamp() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void Report::set_has_report_timestamp() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void Report::clear_has_report_timestamp() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void Report::clear_report_timestamp() {
+  report_timestamp_ = GOOGLE_ULONGLONG(0);
+  clear_has_report_timestamp();
+}
+inline ::google::protobuf::uint64 Report::report_timestamp() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.report_timestamp)
+  return report_timestamp_;
+}
+inline void Report::set_report_timestamp(::google::protobuf::uint64 value) {
+  set_has_report_timestamp();
+  report_timestamp_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.Report.report_timestamp)
+}
+
+// -------------------------------------------------------------------
+
+// SendReportRequest
+
+// required .bgs.protocol.report.v1.Report report = 1;
+inline bool SendReportRequest::has_report() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SendReportRequest::set_has_report() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SendReportRequest::clear_has_report() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SendReportRequest::clear_report() {
+  if (report_ != NULL) report_->::bgs::protocol::report::v1::Report::Clear();
+  clear_has_report();
+}
+inline const ::bgs::protocol::report::v1::Report& SendReportRequest::report() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.SendReportRequest.report)
+  return report_ != NULL ? *report_ : *default_instance_->report_;
+}
+inline ::bgs::protocol::report::v1::Report* SendReportRequest::mutable_report() {
+  set_has_report();
+  if (report_ == NULL) report_ = new ::bgs::protocol::report::v1::Report;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.SendReportRequest.report)
+  return report_;
+}
+inline ::bgs::protocol::report::v1::Report* SendReportRequest::release_report() {
+  clear_has_report();
+  ::bgs::protocol::report::v1::Report* temp = report_;
+  report_ = NULL;
+  return temp;
+}
+inline void SendReportRequest::set_allocated_report(::bgs::protocol::report::v1::Report* report) {
+  delete report_;
+  report_ = report;
+  if (report) {
+    set_has_report();
+  } else {
+    clear_has_report();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.SendReportRequest.report)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace report
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_report_5fservice_2eproto__INCLUDED
diff --git a/src/server/proto/Client/resource_service.pb.cc b/src/server/proto/Client/resource_service.pb.cc
new file mode 100644
index 00000000000..d3b5466487f
--- /dev/null
+++ b/src/server/proto/Client/resource_service.pb.cc
@@ -0,0 +1,489 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: resource_service.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "resource_service.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+#include "BattlenetRpcErrorCodes.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace resources {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* ContentHandleRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ContentHandleRequest_reflection_ = NULL;
+const ::google::protobuf::ServiceDescriptor* ResourcesService_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_resource_5fservice_2eproto() {
+  protobuf_AddDesc_resource_5fservice_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "resource_service.proto");
+  GOOGLE_CHECK(file != NULL);
+  ContentHandleRequest_descriptor_ = file->message_type(0);
+  static const int ContentHandleRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandleRequest, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandleRequest, stream_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandleRequest, version_),
+  };
+  ContentHandleRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ContentHandleRequest_descriptor_,
+      ContentHandleRequest::default_instance_,
+      ContentHandleRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandleRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContentHandleRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ContentHandleRequest));
+  ResourcesService_descriptor_ = file->service(0);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_resource_5fservice_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ContentHandleRequest_descriptor_, &ContentHandleRequest::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_resource_5fservice_2eproto() {
+  delete ContentHandleRequest::default_instance_;
+  delete ContentHandleRequest_reflection_;
+}
+
+void protobuf_AddDesc_resource_5fservice_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_content_5fhandle_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\026resource_service.proto\022\031bgs.protocol.r"
+    "esources.v1\032\032content_handle_types.proto\032"
+    "\017rpc_types.proto\"T\n\024ContentHandleRequest"
+    "\022\017\n\007program\030\001 \002(\007\022\016\n\006stream\030\002 \002(\007\022\033\n\007ver"
+    "sion\030\003 \001(\007:\n17017296192\240\001\n\020ResourcesServ"
+    "ice\022f\n\020GetContentHandle\022/.bgs.protocol.r"
+    "esources.v1.ContentHandleRequest\032\033.bgs.p"
+    "rotocol.ContentHandle\"\004\200\265\030\001\032$\312>!bnet.pro"
+    "tocol.resources.ResourcesB\005H\001\200\001\000", 352);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "resource_service.proto", &protobuf_RegisterTypes);
+  ContentHandleRequest::default_instance_ = new ContentHandleRequest();
+  ContentHandleRequest::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_resource_5fservice_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_resource_5fservice_2eproto {
+  StaticDescriptorInitializer_resource_5fservice_2eproto() {
+    protobuf_AddDesc_resource_5fservice_2eproto();
+  }
+} static_descriptor_initializer_resource_5fservice_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ContentHandleRequest::kProgramFieldNumber;
+const int ContentHandleRequest::kStreamFieldNumber;
+const int ContentHandleRequest::kVersionFieldNumber;
+#endif  // !_MSC_VER
+
+ContentHandleRequest::ContentHandleRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.resources.v1.ContentHandleRequest)
+}
+
+void ContentHandleRequest::InitAsDefaultInstance() {
+}
+
+ContentHandleRequest::ContentHandleRequest(const ContentHandleRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.resources.v1.ContentHandleRequest)
+}
+
+void ContentHandleRequest::SharedCtor() {
+  _cached_size_ = 0;
+  program_ = 0u;
+  stream_ = 0u;
+  version_ = 1701729619u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ContentHandleRequest::~ContentHandleRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.resources.v1.ContentHandleRequest)
+  SharedDtor();
+}
+
+void ContentHandleRequest::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ContentHandleRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ContentHandleRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ContentHandleRequest_descriptor_;
+}
+
+const ContentHandleRequest& ContentHandleRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_resource_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ContentHandleRequest* ContentHandleRequest::default_instance_ = NULL;
+
+ContentHandleRequest* ContentHandleRequest::New() const {
+  return new ContentHandleRequest;
+}
+
+void ContentHandleRequest::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ContentHandleRequest*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 7) {
+    ZR_(program_, stream_);
+    version_ = 1701729619u;
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ContentHandleRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.resources.v1.ContentHandleRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required fixed32 program = 1;
+      case 1: {
+        if (tag == 13) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(21)) goto parse_stream;
+        break;
+      }
+
+      // required fixed32 stream = 2;
+      case 2: {
+        if (tag == 21) {
+         parse_stream:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &stream_)));
+          set_has_stream();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(29)) goto parse_version;
+        break;
+      }
+
+      // optional fixed32 version = 3 [default = 1701729619];
+      case 3: {
+        if (tag == 29) {
+         parse_version:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &version_)));
+          set_has_version();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.resources.v1.ContentHandleRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.resources.v1.ContentHandleRequest)
+  return false;
+#undef DO_
+}
+
+void ContentHandleRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.resources.v1.ContentHandleRequest)
+  // required fixed32 program = 1;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(1, this->program(), output);
+  }
+
+  // required fixed32 stream = 2;
+  if (has_stream()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(2, this->stream(), output);
+  }
+
+  // optional fixed32 version = 3 [default = 1701729619];
+  if (has_version()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(3, this->version(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.resources.v1.ContentHandleRequest)
+}
+
+::google::protobuf::uint8* ContentHandleRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.resources.v1.ContentHandleRequest)
+  // required fixed32 program = 1;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(1, this->program(), target);
+  }
+
+  // required fixed32 stream = 2;
+  if (has_stream()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(2, this->stream(), target);
+  }
+
+  // optional fixed32 version = 3 [default = 1701729619];
+  if (has_version()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(3, this->version(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.resources.v1.ContentHandleRequest)
+  return target;
+}
+
+int ContentHandleRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required fixed32 program = 1;
+    if (has_program()) {
+      total_size += 1 + 4;
+    }
+
+    // required fixed32 stream = 2;
+    if (has_stream()) {
+      total_size += 1 + 4;
+    }
+
+    // optional fixed32 version = 3 [default = 1701729619];
+    if (has_version()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ContentHandleRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ContentHandleRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ContentHandleRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ContentHandleRequest::MergeFrom(const ContentHandleRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_stream()) {
+      set_stream(from.stream());
+    }
+    if (from.has_version()) {
+      set_version(from.version());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ContentHandleRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ContentHandleRequest::CopyFrom(const ContentHandleRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ContentHandleRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  return true;
+}
+
+void ContentHandleRequest::Swap(ContentHandleRequest* other) {
+  if (other != this) {
+    std::swap(program_, other->program_);
+    std::swap(stream_, other->stream_);
+    std::swap(version_, other->version_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ContentHandleRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ContentHandleRequest_descriptor_;
+  metadata.reflection = ContentHandleRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* ResourcesService::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ResourcesService_descriptor_;
+}
+
+void ResourcesService::GetContentHandle(::bgs::protocol::resources::v1::ContentHandleRequest const* request, std::function<void(::bgs::protocol::ContentHandle const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method ResourcesService.GetContentHandle(bgs.protocol.resources.v1.ContentHandleRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::ContentHandle response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void ResourcesService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::resources::v1::ContentHandleRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for ResourcesService.GetContentHandle server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::ContentHandle response;
+      uint32 status = HandleGetContentHandle(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method ResourcesService.GetContentHandle(bgs.protocol.resources.v1.ContentHandleRequest{ %s }) returned bgs.protocol.ContentHandle{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 1, token, &response);
+      else
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 ResourcesService::HandleGetContentHandle(::bgs::protocol::resources::v1::ContentHandleRequest const* request, ::bgs::protocol::ContentHandle* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method ResourcesService.GetContentHandle({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace resources
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/resource_service.pb.h b/src/server/proto/Client/resource_service.pb.h
new file mode 100644
index 00000000000..8d8613a9ea2
--- /dev/null
+++ b/src/server/proto/Client/resource_service.pb.h
@@ -0,0 +1,274 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: resource_service.proto
+
+#ifndef PROTOBUF_resource_5fservice_2eproto__INCLUDED
+#define PROTOBUF_resource_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 "content_handle_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 resources {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_resource_5fservice_2eproto();
+void protobuf_AssignDesc_resource_5fservice_2eproto();
+void protobuf_ShutdownFile_resource_5fservice_2eproto();
+
+class ContentHandleRequest;
+
+// ===================================================================
+
+class TC_SHARED_API ContentHandleRequest : public ::google::protobuf::Message {
+ public:
+  ContentHandleRequest();
+  virtual ~ContentHandleRequest();
+
+  ContentHandleRequest(const ContentHandleRequest& from);
+
+  inline ContentHandleRequest& operator=(const ContentHandleRequest& 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 ContentHandleRequest& default_instance();
+
+  void Swap(ContentHandleRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ContentHandleRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ContentHandleRequest& from);
+  void MergeFrom(const ContentHandleRequest& 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 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);
+
+  // required fixed32 stream = 2;
+  inline bool has_stream() const;
+  inline void clear_stream();
+  static const int kStreamFieldNumber = 2;
+  inline ::google::protobuf::uint32 stream() const;
+  inline void set_stream(::google::protobuf::uint32 value);
+
+  // optional fixed32 version = 3 [default = 1701729619];
+  inline bool has_version() const;
+  inline void clear_version();
+  static const int kVersionFieldNumber = 3;
+  inline ::google::protobuf::uint32 version() const;
+  inline void set_version(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.resources.v1.ContentHandleRequest)
+ private:
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_stream();
+  inline void clear_has_stream();
+  inline void set_has_version();
+  inline void clear_has_version();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 program_;
+  ::google::protobuf::uint32 stream_;
+  ::google::protobuf::uint32 version_;
+  friend void TC_SHARED_API protobuf_AddDesc_resource_5fservice_2eproto();
+  friend void protobuf_AssignDesc_resource_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_resource_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ContentHandleRequest* default_instance_;
+};
+// ===================================================================
+
+class TC_SHARED_API ResourcesService : public ServiceBase
+{
+ public:
+
+  template<typename HashSelector>
+  explicit ResourcesService(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  typedef std::integral_constant<uint32, 0xECBE75BAu> OriginalHash;
+  typedef std::integral_constant<uint32, 0x4B104C53u> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void GetContentHandle(::bgs::protocol::resources::v1::ContentHandleRequest const* request, std::function<void(::bgs::protocol::ContentHandle const*)> responseCallback);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleGetContentHandle(::bgs::protocol::resources::v1::ContentHandleRequest const* request, ::bgs::protocol::ContentHandle* response);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ResourcesService);
+};
+
+// ===================================================================
+
+
+// ===================================================================
+
+// ContentHandleRequest
+
+// required fixed32 program = 1;
+inline bool ContentHandleRequest::has_program() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ContentHandleRequest::set_has_program() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ContentHandleRequest::clear_has_program() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ContentHandleRequest::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 ContentHandleRequest::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.resources.v1.ContentHandleRequest.program)
+  return program_;
+}
+inline void ContentHandleRequest::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.resources.v1.ContentHandleRequest.program)
+}
+
+// required fixed32 stream = 2;
+inline bool ContentHandleRequest::has_stream() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ContentHandleRequest::set_has_stream() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ContentHandleRequest::clear_has_stream() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ContentHandleRequest::clear_stream() {
+  stream_ = 0u;
+  clear_has_stream();
+}
+inline ::google::protobuf::uint32 ContentHandleRequest::stream() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.resources.v1.ContentHandleRequest.stream)
+  return stream_;
+}
+inline void ContentHandleRequest::set_stream(::google::protobuf::uint32 value) {
+  set_has_stream();
+  stream_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.resources.v1.ContentHandleRequest.stream)
+}
+
+// optional fixed32 version = 3 [default = 1701729619];
+inline bool ContentHandleRequest::has_version() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ContentHandleRequest::set_has_version() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ContentHandleRequest::clear_has_version() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ContentHandleRequest::clear_version() {
+  version_ = 1701729619u;
+  clear_has_version();
+}
+inline ::google::protobuf::uint32 ContentHandleRequest::version() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.resources.v1.ContentHandleRequest.version)
+  return version_;
+}
+inline void ContentHandleRequest::set_version(::google::protobuf::uint32 value) {
+  set_has_version();
+  version_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.resources.v1.ContentHandleRequest.version)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace resources
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_resource_5fservice_2eproto__INCLUDED
diff --git a/src/server/proto/Client/role_types.pb.cc b/src/server/proto/Client/role_types.pb.cc
new file mode 100644
index 00000000000..73bc233b876
--- /dev/null
+++ b/src/server/proto/Client/role_types.pb.cc
@@ -0,0 +1,815 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: role_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "role_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+
+namespace {
+
+const ::google::protobuf::Descriptor* Role_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Role_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_role_5ftypes_2eproto() {
+  protobuf_AddDesc_role_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "role_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  Role_descriptor_ = file->message_type(0);
+  static const int Role_offsets_[10] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, privilege_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, assignable_role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, required_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, unique_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, relegation_role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, attribute_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, kickable_role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, removable_role_),
+  };
+  Role_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Role_descriptor_,
+      Role::default_instance_,
+      Role_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Role, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Role));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_role_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Role_descriptor_, &Role::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_role_5ftypes_2eproto() {
+  delete Role::default_instance_;
+  delete Role_reflection_;
+}
+
+void protobuf_AddDesc_role_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\020role_types.proto\022\014bgs.protocol\032\025attrib"
+    "ute_types.proto\"\374\001\n\004Role\022\n\n\002id\030\001 \002(\r\022\014\n\004"
+    "name\030\002 \002(\t\022\021\n\tprivilege\030\003 \003(\t\022\033\n\017assigna"
+    "ble_role\030\004 \003(\rB\002\020\001\022\027\n\010required\030\005 \001(\010:\005fa"
+    "lse\022\025\n\006unique\030\006 \001(\010:\005false\022\027\n\017relegation"
+    "_role\030\007 \001(\r\022*\n\tattribute\030\010 \003(\0132\027.bgs.pro"
+    "tocol.Attribute\022\031\n\rkickable_role\030\t \003(\rB\002"
+    "\020\001\022\032\n\016removable_role\030\n \003(\rB\002\020\001B\002H\001", 314);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "role_types.proto", &protobuf_RegisterTypes);
+  Role::default_instance_ = new Role();
+  Role::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_role_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_role_5ftypes_2eproto {
+  StaticDescriptorInitializer_role_5ftypes_2eproto() {
+    protobuf_AddDesc_role_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_role_5ftypes_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Role::kIdFieldNumber;
+const int Role::kNameFieldNumber;
+const int Role::kPrivilegeFieldNumber;
+const int Role::kAssignableRoleFieldNumber;
+const int Role::kRequiredFieldNumber;
+const int Role::kUniqueFieldNumber;
+const int Role::kRelegationRoleFieldNumber;
+const int Role::kAttributeFieldNumber;
+const int Role::kKickableRoleFieldNumber;
+const int Role::kRemovableRoleFieldNumber;
+#endif  // !_MSC_VER
+
+Role::Role()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.Role)
+}
+
+void Role::InitAsDefaultInstance() {
+}
+
+Role::Role(const Role& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.Role)
+}
+
+void Role::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = 0u;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  required_ = false;
+  unique_ = false;
+  relegation_role_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Role::~Role() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.Role)
+  SharedDtor();
+}
+
+void Role::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void Role::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Role::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Role_descriptor_;
+}
+
+const Role& Role::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_role_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Role* Role::default_instance_ = NULL;
+
+Role* Role::New() const {
+  return new Role;
+}
+
+void Role::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<Role*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 115) {
+    ZR_(id_, unique_);
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    relegation_role_ = 0u;
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  privilege_.Clear();
+  assignable_role_.Clear();
+  attribute_.Clear();
+  kickable_role_.Clear();
+  removable_role_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Role::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.Role)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required uint32 id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_name;
+        break;
+      }
+
+      // required string name = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_privilege;
+        break;
+      }
+
+      // repeated string privilege = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_privilege:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->add_privilege()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->privilege(this->privilege_size() - 1).data(),
+            this->privilege(this->privilege_size() - 1).length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "privilege");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_privilege;
+        if (input->ExpectTag(34)) goto parse_assignable_role;
+        break;
+      }
+
+      // repeated uint32 assignable_role = 4 [packed = true];
+      case 4: {
+        if (tag == 34) {
+         parse_assignable_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_assignable_role())));
+        } else if (tag == 32) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 34, input, this->mutable_assignable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_required;
+        break;
+      }
+
+      // optional bool required = 5 [default = false];
+      case 5: {
+        if (tag == 40) {
+         parse_required:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &required_)));
+          set_has_required();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_unique;
+        break;
+      }
+
+      // optional bool unique = 6 [default = false];
+      case 6: {
+        if (tag == 48) {
+         parse_unique:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &unique_)));
+          set_has_unique();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_relegation_role;
+        break;
+      }
+
+      // optional uint32 relegation_role = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_relegation_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &relegation_role_)));
+          set_has_relegation_role();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_attribute;
+        break;
+      }
+
+      // repeated .bgs.protocol.Attribute attribute = 8;
+      case 8: {
+        if (tag == 66) {
+         parse_attribute:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attribute()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(66)) goto parse_attribute;
+        if (input->ExpectTag(74)) goto parse_kickable_role;
+        break;
+      }
+
+      // repeated uint32 kickable_role = 9 [packed = true];
+      case 9: {
+        if (tag == 74) {
+         parse_kickable_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_kickable_role())));
+        } else if (tag == 72) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 74, input, this->mutable_kickable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_removable_role;
+        break;
+      }
+
+      // repeated uint32 removable_role = 10 [packed = true];
+      case 10: {
+        if (tag == 82) {
+         parse_removable_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_removable_role())));
+        } else if (tag == 80) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 82, input, this->mutable_removable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.Role)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.Role)
+  return false;
+#undef DO_
+}
+
+void Role::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.Role)
+  // required uint32 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->id(), output);
+  }
+
+  // required string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->name(), output);
+  }
+
+  // repeated string privilege = 3;
+  for (int i = 0; i < this->privilege_size(); i++) {
+  ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+    this->privilege(i).data(), this->privilege(i).length(),
+    ::google::protobuf::internal::WireFormat::SERIALIZE,
+    "privilege");
+    ::google::protobuf::internal::WireFormatLite::WriteString(
+      3, this->privilege(i), output);
+  }
+
+  // repeated uint32 assignable_role = 4 [packed = true];
+  if (this->assignable_role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(4, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_assignable_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->assignable_role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->assignable_role(i), output);
+  }
+
+  // optional bool required = 5 [default = false];
+  if (has_required()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->required(), output);
+  }
+
+  // optional bool unique = 6 [default = false];
+  if (has_unique()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(6, this->unique(), output);
+  }
+
+  // optional uint32 relegation_role = 7;
+  if (has_relegation_role()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->relegation_role(), output);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 8;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      8, this->attribute(i), output);
+  }
+
+  // repeated uint32 kickable_role = 9 [packed = true];
+  if (this->kickable_role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(9, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_kickable_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->kickable_role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->kickable_role(i), output);
+  }
+
+  // repeated uint32 removable_role = 10 [packed = true];
+  if (this->removable_role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(10, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_removable_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->removable_role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->removable_role(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.Role)
+}
+
+::google::protobuf::uint8* Role::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Role)
+  // required uint32 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->id(), target);
+  }
+
+  // required string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->name(), target);
+  }
+
+  // repeated string privilege = 3;
+  for (int i = 0; i < this->privilege_size(); i++) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->privilege(i).data(), this->privilege(i).length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "privilege");
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteStringToArray(3, this->privilege(i), target);
+  }
+
+  // repeated uint32 assignable_role = 4 [packed = true];
+  if (this->assignable_role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      4,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _assignable_role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->assignable_role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->assignable_role(i), target);
+  }
+
+  // optional bool required = 5 [default = false];
+  if (has_required()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->required(), target);
+  }
+
+  // optional bool unique = 6 [default = false];
+  if (has_unique()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(6, this->unique(), target);
+  }
+
+  // optional uint32 relegation_role = 7;
+  if (has_relegation_role()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->relegation_role(), target);
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 8;
+  for (int i = 0; i < this->attribute_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        8, this->attribute(i), target);
+  }
+
+  // repeated uint32 kickable_role = 9 [packed = true];
+  if (this->kickable_role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      9,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _kickable_role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->kickable_role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->kickable_role(i), target);
+  }
+
+  // repeated uint32 removable_role = 10 [packed = true];
+  if (this->removable_role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      10,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _removable_role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->removable_role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->removable_role(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Role)
+  return target;
+}
+
+int Role::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->id());
+    }
+
+    // required string name = 2;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional bool required = 5 [default = false];
+    if (has_required()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool unique = 6 [default = false];
+    if (has_unique()) {
+      total_size += 1 + 1;
+    }
+
+    // optional uint32 relegation_role = 7;
+    if (has_relegation_role()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->relegation_role());
+    }
+
+  }
+  // repeated string privilege = 3;
+  total_size += 1 * this->privilege_size();
+  for (int i = 0; i < this->privilege_size(); i++) {
+    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(
+      this->privilege(i));
+  }
+
+  // repeated uint32 assignable_role = 4 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->assignable_role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->assignable_role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _assignable_role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated .bgs.protocol.Attribute attribute = 8;
+  total_size += 1 * this->attribute_size();
+  for (int i = 0; i < this->attribute_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attribute(i));
+  }
+
+  // repeated uint32 kickable_role = 9 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->kickable_role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->kickable_role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _kickable_role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  // repeated uint32 removable_role = 10 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->removable_role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->removable_role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _removable_role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Role::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Role* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Role*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Role::MergeFrom(const Role& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  privilege_.MergeFrom(from.privilege_);
+  assignable_role_.MergeFrom(from.assignable_role_);
+  attribute_.MergeFrom(from.attribute_);
+  kickable_role_.MergeFrom(from.kickable_role_);
+  removable_role_.MergeFrom(from.removable_role_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_required()) {
+      set_required(from.required());
+    }
+    if (from.has_unique()) {
+      set_unique(from.unique());
+    }
+    if (from.has_relegation_role()) {
+      set_relegation_role(from.relegation_role());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Role::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Role::CopyFrom(const Role& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Role::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->attribute())) return false;
+  return true;
+}
+
+void Role::Swap(Role* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(name_, other->name_);
+    privilege_.Swap(&other->privilege_);
+    assignable_role_.Swap(&other->assignable_role_);
+    std::swap(required_, other->required_);
+    std::swap(unique_, other->unique_);
+    std::swap(relegation_role_, other->relegation_role_);
+    attribute_.Swap(&other->attribute_);
+    kickable_role_.Swap(&other->kickable_role_);
+    removable_role_.Swap(&other->removable_role_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Role::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Role_descriptor_;
+  metadata.reflection = Role_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/role_types.pb.h b/src/server/proto/Client/role_types.pb.h
new file mode 100644
index 00000000000..33abb25e127
--- /dev/null
+++ b/src/server/proto/Client/role_types.pb.h
@@ -0,0 +1,610 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: role_types.proto
+
+#ifndef PROTOBUF_role_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_role_5ftypes_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 "attribute_types.pb.h"
+#include "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_role_5ftypes_2eproto();
+void protobuf_AssignDesc_role_5ftypes_2eproto();
+void protobuf_ShutdownFile_role_5ftypes_2eproto();
+
+class Role;
+
+// ===================================================================
+
+class TC_SHARED_API Role : public ::google::protobuf::Message {
+ public:
+  Role();
+  virtual ~Role();
+
+  Role(const Role& from);
+
+  inline Role& operator=(const Role& 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 Role& default_instance();
+
+  void Swap(Role* other);
+
+  // implements Message ----------------------------------------------
+
+  Role* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Role& from);
+  void MergeFrom(const Role& 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 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // required string name = 2;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 2;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // repeated string privilege = 3;
+  inline int privilege_size() const;
+  inline void clear_privilege();
+  static const int kPrivilegeFieldNumber = 3;
+  inline const ::std::string& privilege(int index) const;
+  inline ::std::string* mutable_privilege(int index);
+  inline void set_privilege(int index, const ::std::string& value);
+  inline void set_privilege(int index, const char* value);
+  inline void set_privilege(int index, const char* value, size_t size);
+  inline ::std::string* add_privilege();
+  inline void add_privilege(const ::std::string& value);
+  inline void add_privilege(const char* value);
+  inline void add_privilege(const char* value, size_t size);
+  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& privilege() const;
+  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_privilege();
+
+  // repeated uint32 assignable_role = 4 [packed = true];
+  inline int assignable_role_size() const;
+  inline void clear_assignable_role();
+  static const int kAssignableRoleFieldNumber = 4;
+  inline ::google::protobuf::uint32 assignable_role(int index) const;
+  inline void set_assignable_role(int index, ::google::protobuf::uint32 value);
+  inline void add_assignable_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      assignable_role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_assignable_role();
+
+  // optional bool required = 5 [default = false];
+  inline bool has_required() const;
+  inline void clear_required();
+  static const int kRequiredFieldNumber = 5;
+  inline bool required() const;
+  inline void set_required(bool value);
+
+  // optional bool unique = 6 [default = false];
+  inline bool has_unique() const;
+  inline void clear_unique();
+  static const int kUniqueFieldNumber = 6;
+  inline bool unique() const;
+  inline void set_unique(bool value);
+
+  // optional uint32 relegation_role = 7;
+  inline bool has_relegation_role() const;
+  inline void clear_relegation_role();
+  static const int kRelegationRoleFieldNumber = 7;
+  inline ::google::protobuf::uint32 relegation_role() const;
+  inline void set_relegation_role(::google::protobuf::uint32 value);
+
+  // repeated .bgs.protocol.Attribute attribute = 8;
+  inline int attribute_size() const;
+  inline void clear_attribute();
+  static const int kAttributeFieldNumber = 8;
+  inline const ::bgs::protocol::Attribute& attribute(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
+  inline ::bgs::protocol::Attribute* add_attribute();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attribute() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attribute();
+
+  // repeated uint32 kickable_role = 9 [packed = true];
+  inline int kickable_role_size() const;
+  inline void clear_kickable_role();
+  static const int kKickableRoleFieldNumber = 9;
+  inline ::google::protobuf::uint32 kickable_role(int index) const;
+  inline void set_kickable_role(int index, ::google::protobuf::uint32 value);
+  inline void add_kickable_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      kickable_role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_kickable_role();
+
+  // repeated uint32 removable_role = 10 [packed = true];
+  inline int removable_role_size() const;
+  inline void clear_removable_role();
+  static const int kRemovableRoleFieldNumber = 10;
+  inline ::google::protobuf::uint32 removable_role(int index) const;
+  inline void set_removable_role(int index, ::google::protobuf::uint32 value);
+  inline void add_removable_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      removable_role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_removable_role();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.Role)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_required();
+  inline void clear_has_required();
+  inline void set_has_unique();
+  inline void clear_has_unique();
+  inline void set_has_relegation_role();
+  inline void clear_has_relegation_role();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* name_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> privilege_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > assignable_role_;
+  mutable int _assignable_role_cached_byte_size_;
+  ::google::protobuf::uint32 id_;
+  bool required_;
+  bool unique_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > kickable_role_;
+  mutable int _kickable_role_cached_byte_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > removable_role_;
+  mutable int _removable_role_cached_byte_size_;
+  ::google::protobuf::uint32 relegation_role_;
+  friend void TC_SHARED_API protobuf_AddDesc_role_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_role_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_role_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Role* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// Role
+
+// required uint32 id = 1;
+inline bool Role::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Role::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Role::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Role::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 Role::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Role.id)
+  return id_;
+}
+inline void Role::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Role.id)
+}
+
+// required string name = 2;
+inline bool Role::has_name() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Role::set_has_name() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Role::clear_has_name() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Role::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& Role::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Role.name)
+  return *name_;
+}
+inline void Role::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.Role.name)
+}
+inline void Role::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.Role.name)
+}
+inline void Role::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Role.name)
+}
+inline ::std::string* Role::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Role.name)
+  return name_;
+}
+inline ::std::string* Role::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Role::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Role.name)
+}
+
+// repeated string privilege = 3;
+inline int Role::privilege_size() const {
+  return privilege_.size();
+}
+inline void Role::clear_privilege() {
+  privilege_.Clear();
+}
+inline const ::std::string& Role::privilege(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Role.privilege)
+  return privilege_.Get(index);
+}
+inline ::std::string* Role::mutable_privilege(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Role.privilege)
+  return privilege_.Mutable(index);
+}
+inline void Role::set_privilege(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:bgs.protocol.Role.privilege)
+  privilege_.Mutable(index)->assign(value);
+}
+inline void Role::set_privilege(int index, const char* value) {
+  privilege_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.Role.privilege)
+}
+inline void Role::set_privilege(int index, const char* value, size_t size) {
+  privilege_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Role.privilege)
+}
+inline ::std::string* Role::add_privilege() {
+  return privilege_.Add();
+}
+inline void Role::add_privilege(const ::std::string& value) {
+  privilege_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.Role.privilege)
+}
+inline void Role::add_privilege(const char* value) {
+  privilege_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:bgs.protocol.Role.privilege)
+}
+inline void Role::add_privilege(const char* value, size_t size) {
+  privilege_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:bgs.protocol.Role.privilege)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+Role::privilege() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.Role.privilege)
+  return privilege_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+Role::mutable_privilege() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.Role.privilege)
+  return &privilege_;
+}
+
+// repeated uint32 assignable_role = 4 [packed = true];
+inline int Role::assignable_role_size() const {
+  return assignable_role_.size();
+}
+inline void Role::clear_assignable_role() {
+  assignable_role_.Clear();
+}
+inline ::google::protobuf::uint32 Role::assignable_role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Role.assignable_role)
+  return assignable_role_.Get(index);
+}
+inline void Role::set_assignable_role(int index, ::google::protobuf::uint32 value) {
+  assignable_role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.Role.assignable_role)
+}
+inline void Role::add_assignable_role(::google::protobuf::uint32 value) {
+  assignable_role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.Role.assignable_role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+Role::assignable_role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.Role.assignable_role)
+  return assignable_role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+Role::mutable_assignable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.Role.assignable_role)
+  return &assignable_role_;
+}
+
+// optional bool required = 5 [default = false];
+inline bool Role::has_required() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void Role::set_has_required() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void Role::clear_has_required() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void Role::clear_required() {
+  required_ = false;
+  clear_has_required();
+}
+inline bool Role::required() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Role.required)
+  return required_;
+}
+inline void Role::set_required(bool value) {
+  set_has_required();
+  required_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Role.required)
+}
+
+// optional bool unique = 6 [default = false];
+inline bool Role::has_unique() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void Role::set_has_unique() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void Role::clear_has_unique() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void Role::clear_unique() {
+  unique_ = false;
+  clear_has_unique();
+}
+inline bool Role::unique() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Role.unique)
+  return unique_;
+}
+inline void Role::set_unique(bool value) {
+  set_has_unique();
+  unique_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Role.unique)
+}
+
+// optional uint32 relegation_role = 7;
+inline bool Role::has_relegation_role() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void Role::set_has_relegation_role() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void Role::clear_has_relegation_role() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void Role::clear_relegation_role() {
+  relegation_role_ = 0u;
+  clear_has_relegation_role();
+}
+inline ::google::protobuf::uint32 Role::relegation_role() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Role.relegation_role)
+  return relegation_role_;
+}
+inline void Role::set_relegation_role(::google::protobuf::uint32 value) {
+  set_has_relegation_role();
+  relegation_role_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Role.relegation_role)
+}
+
+// repeated .bgs.protocol.Attribute attribute = 8;
+inline int Role::attribute_size() const {
+  return attribute_.size();
+}
+inline void Role::clear_attribute() {
+  attribute_.Clear();
+}
+inline const ::bgs::protocol::Attribute& Role::attribute(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Role.attribute)
+  return attribute_.Get(index);
+}
+inline ::bgs::protocol::Attribute* Role::mutable_attribute(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Role.attribute)
+  return attribute_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* Role::add_attribute() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.Role.attribute)
+  return attribute_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+Role::attribute() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.Role.attribute)
+  return attribute_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+Role::mutable_attribute() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.Role.attribute)
+  return &attribute_;
+}
+
+// repeated uint32 kickable_role = 9 [packed = true];
+inline int Role::kickable_role_size() const {
+  return kickable_role_.size();
+}
+inline void Role::clear_kickable_role() {
+  kickable_role_.Clear();
+}
+inline ::google::protobuf::uint32 Role::kickable_role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Role.kickable_role)
+  return kickable_role_.Get(index);
+}
+inline void Role::set_kickable_role(int index, ::google::protobuf::uint32 value) {
+  kickable_role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.Role.kickable_role)
+}
+inline void Role::add_kickable_role(::google::protobuf::uint32 value) {
+  kickable_role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.Role.kickable_role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+Role::kickable_role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.Role.kickable_role)
+  return kickable_role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+Role::mutable_kickable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.Role.kickable_role)
+  return &kickable_role_;
+}
+
+// repeated uint32 removable_role = 10 [packed = true];
+inline int Role::removable_role_size() const {
+  return removable_role_.size();
+}
+inline void Role::clear_removable_role() {
+  removable_role_.Clear();
+}
+inline ::google::protobuf::uint32 Role::removable_role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Role.removable_role)
+  return removable_role_.Get(index);
+}
+inline void Role::set_removable_role(int index, ::google::protobuf::uint32 value) {
+  removable_role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.Role.removable_role)
+}
+inline void Role::add_removable_role(::google::protobuf::uint32 value) {
+  removable_role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.Role.removable_role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+Role::removable_role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.Role.removable_role)
+  return removable_role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+Role::mutable_removable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.Role.removable_role)
+  return &removable_role_;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_role_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/rpc_config.pb.cc b/src/server/proto/Client/rpc_config.pb.cc
new file mode 100644
index 00000000000..63597f6618d
--- /dev/null
+++ b/src/server/proto/Client/rpc_config.pb.cc
@@ -0,0 +1,1952 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: rpc_config.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "rpc_config.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace config {
+
+namespace {
+
+const ::google::protobuf::Descriptor* RPCMethodConfig_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RPCMethodConfig_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RPCMeterConfig_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RPCMeterConfig_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ProtocolAlias_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ProtocolAlias_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ServiceAliases_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ServiceAliases_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_rpc_5fconfig_2eproto() {
+  protobuf_AddDesc_rpc_5fconfig_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "rpc_config.proto");
+  GOOGLE_CHECK(file != NULL);
+  RPCMethodConfig_descriptor_ = file->message_type(0);
+  static const int RPCMethodConfig_offsets_[15] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, service_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, method_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, fixed_call_cost_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, fixed_packet_size_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, variable_multiplier_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, multiplier_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, rate_limit_count_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, rate_limit_seconds_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, max_packet_size_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, max_encoded_size_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, timeout_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, cap_balance_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, income_per_second_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, service_hash_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, method_id_),
+  };
+  RPCMethodConfig_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RPCMethodConfig_descriptor_,
+      RPCMethodConfig::default_instance_,
+      RPCMethodConfig_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMethodConfig, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RPCMethodConfig));
+  RPCMeterConfig_descriptor_ = file->message_type(1);
+  static const int RPCMeterConfig_offsets_[5] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMeterConfig, method_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMeterConfig, income_per_second_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMeterConfig, initial_balance_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMeterConfig, cap_balance_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMeterConfig, startup_period_),
+  };
+  RPCMeterConfig_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RPCMeterConfig_descriptor_,
+      RPCMeterConfig::default_instance_,
+      RPCMeterConfig_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMeterConfig, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RPCMeterConfig, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RPCMeterConfig));
+  ProtocolAlias_descriptor_ = file->message_type(2);
+  static const int ProtocolAlias_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtocolAlias, server_service_name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtocolAlias, client_service_name_),
+  };
+  ProtocolAlias_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ProtocolAlias_descriptor_,
+      ProtocolAlias::default_instance_,
+      ProtocolAlias_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtocolAlias, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProtocolAlias, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ProtocolAlias));
+  ServiceAliases_descriptor_ = file->message_type(3);
+  static const int ServiceAliases_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceAliases, protocol_alias_),
+  };
+  ServiceAliases_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ServiceAliases_descriptor_,
+      ServiceAliases::default_instance_,
+      ServiceAliases_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceAliases, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceAliases, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ServiceAliases));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_rpc_5fconfig_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RPCMethodConfig_descriptor_, &RPCMethodConfig::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RPCMeterConfig_descriptor_, &RPCMeterConfig::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ProtocolAlias_descriptor_, &ProtocolAlias::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ServiceAliases_descriptor_, &ServiceAliases::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_rpc_5fconfig_2eproto() {
+  delete RPCMethodConfig::default_instance_;
+  delete RPCMethodConfig_reflection_;
+  delete RPCMeterConfig::default_instance_;
+  delete RPCMeterConfig_reflection_;
+  delete ProtocolAlias::default_instance_;
+  delete ProtocolAlias_reflection_;
+  delete ServiceAliases::default_instance_;
+  delete ServiceAliases_reflection_;
+}
+
+void protobuf_AddDesc_rpc_5fconfig_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\020rpc_config.proto\022\023bgs.protocol.config\""
+    "\213\003\n\017RPCMethodConfig\022\030\n\014service_name\030\001 \001("
+    "\tB\002\030\001\022\027\n\013method_name\030\002 \001(\tB\002\030\001\022\032\n\017fixed_"
+    "call_cost\030\003 \001(\r:\0011\022\034\n\021fixed_packet_size\030"
+    "\004 \001(\r:\0010\022\036\n\023variable_multiplier\030\005 \001(\002:\0010"
+    "\022\025\n\nmultiplier\030\006 \001(\002:\0011\022\030\n\020rate_limit_co"
+    "unt\030\007 \001(\r\022\032\n\022rate_limit_seconds\030\010 \001(\r\022\027\n"
+    "\017max_packet_size\030\t \001(\r\022\030\n\020max_encoded_si"
+    "ze\030\n \001(\r\022\017\n\007timeout\030\013 \001(\002\022\023\n\013cap_balance"
+    "\030\014 \001(\r\022\034\n\021income_per_second\030\r \001(\002:\0010\022\024\n\014"
+    "service_hash\030\016 \001(\r\022\021\n\tmethod_id\030\017 \001(\r\"\255\001"
+    "\n\016RPCMeterConfig\0224\n\006method\030\001 \003(\0132$.bgs.p"
+    "rotocol.config.RPCMethodConfig\022\034\n\021income"
+    "_per_second\030\002 \001(\r:\0011\022\027\n\017initial_balance\030"
+    "\003 \001(\r\022\023\n\013cap_balance\030\004 \001(\r\022\031\n\016startup_pe"
+    "riod\030\005 \001(\002:\0010\"I\n\rProtocolAlias\022\033\n\023server"
+    "_service_name\030\001 \002(\t\022\033\n\023client_service_na"
+    "me\030\002 \002(\t\"L\n\016ServiceAliases\022:\n\016protocol_a"
+    "lias\030\001 \003(\0132\".bgs.protocol.config.Protoco"
+    "lAliasB\002H\001", 770);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "rpc_config.proto", &protobuf_RegisterTypes);
+  RPCMethodConfig::default_instance_ = new RPCMethodConfig();
+  RPCMeterConfig::default_instance_ = new RPCMeterConfig();
+  ProtocolAlias::default_instance_ = new ProtocolAlias();
+  ServiceAliases::default_instance_ = new ServiceAliases();
+  RPCMethodConfig::default_instance_->InitAsDefaultInstance();
+  RPCMeterConfig::default_instance_->InitAsDefaultInstance();
+  ProtocolAlias::default_instance_->InitAsDefaultInstance();
+  ServiceAliases::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_rpc_5fconfig_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_rpc_5fconfig_2eproto {
+  StaticDescriptorInitializer_rpc_5fconfig_2eproto() {
+    protobuf_AddDesc_rpc_5fconfig_2eproto();
+  }
+} static_descriptor_initializer_rpc_5fconfig_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RPCMethodConfig::kServiceNameFieldNumber;
+const int RPCMethodConfig::kMethodNameFieldNumber;
+const int RPCMethodConfig::kFixedCallCostFieldNumber;
+const int RPCMethodConfig::kFixedPacketSizeFieldNumber;
+const int RPCMethodConfig::kVariableMultiplierFieldNumber;
+const int RPCMethodConfig::kMultiplierFieldNumber;
+const int RPCMethodConfig::kRateLimitCountFieldNumber;
+const int RPCMethodConfig::kRateLimitSecondsFieldNumber;
+const int RPCMethodConfig::kMaxPacketSizeFieldNumber;
+const int RPCMethodConfig::kMaxEncodedSizeFieldNumber;
+const int RPCMethodConfig::kTimeoutFieldNumber;
+const int RPCMethodConfig::kCapBalanceFieldNumber;
+const int RPCMethodConfig::kIncomePerSecondFieldNumber;
+const int RPCMethodConfig::kServiceHashFieldNumber;
+const int RPCMethodConfig::kMethodIdFieldNumber;
+#endif  // !_MSC_VER
+
+RPCMethodConfig::RPCMethodConfig()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.config.RPCMethodConfig)
+}
+
+void RPCMethodConfig::InitAsDefaultInstance() {
+}
+
+RPCMethodConfig::RPCMethodConfig(const RPCMethodConfig& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.config.RPCMethodConfig)
+}
+
+void RPCMethodConfig::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  method_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  fixed_call_cost_ = 1u;
+  fixed_packet_size_ = 0u;
+  variable_multiplier_ = 0;
+  multiplier_ = 1;
+  rate_limit_count_ = 0u;
+  rate_limit_seconds_ = 0u;
+  max_packet_size_ = 0u;
+  max_encoded_size_ = 0u;
+  timeout_ = 0;
+  cap_balance_ = 0u;
+  income_per_second_ = 0;
+  service_hash_ = 0u;
+  method_id_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RPCMethodConfig::~RPCMethodConfig() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.config.RPCMethodConfig)
+  SharedDtor();
+}
+
+void RPCMethodConfig::SharedDtor() {
+  if (service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete service_name_;
+  }
+  if (method_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete method_name_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void RPCMethodConfig::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RPCMethodConfig::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RPCMethodConfig_descriptor_;
+}
+
+const RPCMethodConfig& RPCMethodConfig::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_rpc_5fconfig_2eproto();
+  return *default_instance_;
+}
+
+RPCMethodConfig* RPCMethodConfig::default_instance_ = NULL;
+
+RPCMethodConfig* RPCMethodConfig::New() const {
+  return new RPCMethodConfig;
+}
+
+void RPCMethodConfig::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<RPCMethodConfig*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 255) {
+    ZR_(fixed_packet_size_, variable_multiplier_);
+    ZR_(rate_limit_count_, rate_limit_seconds_);
+    if (has_service_name()) {
+      if (service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        service_name_->clear();
+      }
+    }
+    if (has_method_name()) {
+      if (method_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        method_name_->clear();
+      }
+    }
+    fixed_call_cost_ = 1u;
+    multiplier_ = 1;
+  }
+  if (_has_bits_[8 / 32] & 32512) {
+    ZR_(max_packet_size_, method_id_);
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RPCMethodConfig::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.config.RPCMethodConfig)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional string service_name = 1 [deprecated = true];
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_service_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->service_name().data(), this->service_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "service_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_method_name;
+        break;
+      }
+
+      // optional string method_name = 2 [deprecated = true];
+      case 2: {
+        if (tag == 18) {
+         parse_method_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_method_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->method_name().data(), this->method_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "method_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_fixed_call_cost;
+        break;
+      }
+
+      // optional uint32 fixed_call_cost = 3 [default = 1];
+      case 3: {
+        if (tag == 24) {
+         parse_fixed_call_cost:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &fixed_call_cost_)));
+          set_has_fixed_call_cost();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_fixed_packet_size;
+        break;
+      }
+
+      // optional uint32 fixed_packet_size = 4 [default = 0];
+      case 4: {
+        if (tag == 32) {
+         parse_fixed_packet_size:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &fixed_packet_size_)));
+          set_has_fixed_packet_size();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(45)) goto parse_variable_multiplier;
+        break;
+      }
+
+      // optional float variable_multiplier = 5 [default = 0];
+      case 5: {
+        if (tag == 45) {
+         parse_variable_multiplier:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &variable_multiplier_)));
+          set_has_variable_multiplier();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(53)) goto parse_multiplier;
+        break;
+      }
+
+      // optional float multiplier = 6 [default = 1];
+      case 6: {
+        if (tag == 53) {
+         parse_multiplier:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &multiplier_)));
+          set_has_multiplier();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_rate_limit_count;
+        break;
+      }
+
+      // optional uint32 rate_limit_count = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_rate_limit_count:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &rate_limit_count_)));
+          set_has_rate_limit_count();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_rate_limit_seconds;
+        break;
+      }
+
+      // optional uint32 rate_limit_seconds = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_rate_limit_seconds:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &rate_limit_seconds_)));
+          set_has_rate_limit_seconds();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(72)) goto parse_max_packet_size;
+        break;
+      }
+
+      // optional uint32 max_packet_size = 9;
+      case 9: {
+        if (tag == 72) {
+         parse_max_packet_size:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &max_packet_size_)));
+          set_has_max_packet_size();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(80)) goto parse_max_encoded_size;
+        break;
+      }
+
+      // optional uint32 max_encoded_size = 10;
+      case 10: {
+        if (tag == 80) {
+         parse_max_encoded_size:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &max_encoded_size_)));
+          set_has_max_encoded_size();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(93)) goto parse_timeout;
+        break;
+      }
+
+      // optional float timeout = 11;
+      case 11: {
+        if (tag == 93) {
+         parse_timeout:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &timeout_)));
+          set_has_timeout();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(96)) goto parse_cap_balance;
+        break;
+      }
+
+      // optional uint32 cap_balance = 12;
+      case 12: {
+        if (tag == 96) {
+         parse_cap_balance:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &cap_balance_)));
+          set_has_cap_balance();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(109)) goto parse_income_per_second;
+        break;
+      }
+
+      // optional float income_per_second = 13 [default = 0];
+      case 13: {
+        if (tag == 109) {
+         parse_income_per_second:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &income_per_second_)));
+          set_has_income_per_second();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(112)) goto parse_service_hash;
+        break;
+      }
+
+      // optional uint32 service_hash = 14;
+      case 14: {
+        if (tag == 112) {
+         parse_service_hash:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &service_hash_)));
+          set_has_service_hash();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(120)) goto parse_method_id;
+        break;
+      }
+
+      // optional uint32 method_id = 15;
+      case 15: {
+        if (tag == 120) {
+         parse_method_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &method_id_)));
+          set_has_method_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.config.RPCMethodConfig)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.config.RPCMethodConfig)
+  return false;
+#undef DO_
+}
+
+void RPCMethodConfig::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.config.RPCMethodConfig)
+  // optional string service_name = 1 [deprecated = true];
+  if (has_service_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->service_name().data(), this->service_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "service_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->service_name(), output);
+  }
+
+  // optional string method_name = 2 [deprecated = true];
+  if (has_method_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->method_name().data(), this->method_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "method_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->method_name(), output);
+  }
+
+  // optional uint32 fixed_call_cost = 3 [default = 1];
+  if (has_fixed_call_cost()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->fixed_call_cost(), output);
+  }
+
+  // optional uint32 fixed_packet_size = 4 [default = 0];
+  if (has_fixed_packet_size()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->fixed_packet_size(), output);
+  }
+
+  // optional float variable_multiplier = 5 [default = 0];
+  if (has_variable_multiplier()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->variable_multiplier(), output);
+  }
+
+  // optional float multiplier = 6 [default = 1];
+  if (has_multiplier()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(6, this->multiplier(), output);
+  }
+
+  // optional uint32 rate_limit_count = 7;
+  if (has_rate_limit_count()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->rate_limit_count(), output);
+  }
+
+  // optional uint32 rate_limit_seconds = 8;
+  if (has_rate_limit_seconds()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->rate_limit_seconds(), output);
+  }
+
+  // optional uint32 max_packet_size = 9;
+  if (has_max_packet_size()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->max_packet_size(), output);
+  }
+
+  // optional uint32 max_encoded_size = 10;
+  if (has_max_encoded_size()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->max_encoded_size(), output);
+  }
+
+  // optional float timeout = 11;
+  if (has_timeout()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(11, this->timeout(), output);
+  }
+
+  // optional uint32 cap_balance = 12;
+  if (has_cap_balance()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(12, this->cap_balance(), output);
+  }
+
+  // optional float income_per_second = 13 [default = 0];
+  if (has_income_per_second()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(13, this->income_per_second(), output);
+  }
+
+  // optional uint32 service_hash = 14;
+  if (has_service_hash()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(14, this->service_hash(), output);
+  }
+
+  // optional uint32 method_id = 15;
+  if (has_method_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(15, this->method_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.config.RPCMethodConfig)
+}
+
+::google::protobuf::uint8* RPCMethodConfig::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.config.RPCMethodConfig)
+  // optional string service_name = 1 [deprecated = true];
+  if (has_service_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->service_name().data(), this->service_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "service_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->service_name(), target);
+  }
+
+  // optional string method_name = 2 [deprecated = true];
+  if (has_method_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->method_name().data(), this->method_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "method_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->method_name(), target);
+  }
+
+  // optional uint32 fixed_call_cost = 3 [default = 1];
+  if (has_fixed_call_cost()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->fixed_call_cost(), target);
+  }
+
+  // optional uint32 fixed_packet_size = 4 [default = 0];
+  if (has_fixed_packet_size()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->fixed_packet_size(), target);
+  }
+
+  // optional float variable_multiplier = 5 [default = 0];
+  if (has_variable_multiplier()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->variable_multiplier(), target);
+  }
+
+  // optional float multiplier = 6 [default = 1];
+  if (has_multiplier()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(6, this->multiplier(), target);
+  }
+
+  // optional uint32 rate_limit_count = 7;
+  if (has_rate_limit_count()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->rate_limit_count(), target);
+  }
+
+  // optional uint32 rate_limit_seconds = 8;
+  if (has_rate_limit_seconds()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(8, this->rate_limit_seconds(), target);
+  }
+
+  // optional uint32 max_packet_size = 9;
+  if (has_max_packet_size()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(9, this->max_packet_size(), target);
+  }
+
+  // optional uint32 max_encoded_size = 10;
+  if (has_max_encoded_size()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->max_encoded_size(), target);
+  }
+
+  // optional float timeout = 11;
+  if (has_timeout()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(11, this->timeout(), target);
+  }
+
+  // optional uint32 cap_balance = 12;
+  if (has_cap_balance()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(12, this->cap_balance(), target);
+  }
+
+  // optional float income_per_second = 13 [default = 0];
+  if (has_income_per_second()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(13, this->income_per_second(), target);
+  }
+
+  // optional uint32 service_hash = 14;
+  if (has_service_hash()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(14, this->service_hash(), target);
+  }
+
+  // optional uint32 method_id = 15;
+  if (has_method_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(15, this->method_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.config.RPCMethodConfig)
+  return target;
+}
+
+int RPCMethodConfig::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional string service_name = 1 [deprecated = true];
+    if (has_service_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->service_name());
+    }
+
+    // optional string method_name = 2 [deprecated = true];
+    if (has_method_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->method_name());
+    }
+
+    // optional uint32 fixed_call_cost = 3 [default = 1];
+    if (has_fixed_call_cost()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->fixed_call_cost());
+    }
+
+    // optional uint32 fixed_packet_size = 4 [default = 0];
+    if (has_fixed_packet_size()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->fixed_packet_size());
+    }
+
+    // optional float variable_multiplier = 5 [default = 0];
+    if (has_variable_multiplier()) {
+      total_size += 1 + 4;
+    }
+
+    // optional float multiplier = 6 [default = 1];
+    if (has_multiplier()) {
+      total_size += 1 + 4;
+    }
+
+    // optional uint32 rate_limit_count = 7;
+    if (has_rate_limit_count()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->rate_limit_count());
+    }
+
+    // optional uint32 rate_limit_seconds = 8;
+    if (has_rate_limit_seconds()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->rate_limit_seconds());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional uint32 max_packet_size = 9;
+    if (has_max_packet_size()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->max_packet_size());
+    }
+
+    // optional uint32 max_encoded_size = 10;
+    if (has_max_encoded_size()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->max_encoded_size());
+    }
+
+    // optional float timeout = 11;
+    if (has_timeout()) {
+      total_size += 1 + 4;
+    }
+
+    // optional uint32 cap_balance = 12;
+    if (has_cap_balance()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->cap_balance());
+    }
+
+    // optional float income_per_second = 13 [default = 0];
+    if (has_income_per_second()) {
+      total_size += 1 + 4;
+    }
+
+    // optional uint32 service_hash = 14;
+    if (has_service_hash()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->service_hash());
+    }
+
+    // optional uint32 method_id = 15;
+    if (has_method_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->method_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RPCMethodConfig::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RPCMethodConfig* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RPCMethodConfig*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RPCMethodConfig::MergeFrom(const RPCMethodConfig& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_service_name()) {
+      set_service_name(from.service_name());
+    }
+    if (from.has_method_name()) {
+      set_method_name(from.method_name());
+    }
+    if (from.has_fixed_call_cost()) {
+      set_fixed_call_cost(from.fixed_call_cost());
+    }
+    if (from.has_fixed_packet_size()) {
+      set_fixed_packet_size(from.fixed_packet_size());
+    }
+    if (from.has_variable_multiplier()) {
+      set_variable_multiplier(from.variable_multiplier());
+    }
+    if (from.has_multiplier()) {
+      set_multiplier(from.multiplier());
+    }
+    if (from.has_rate_limit_count()) {
+      set_rate_limit_count(from.rate_limit_count());
+    }
+    if (from.has_rate_limit_seconds()) {
+      set_rate_limit_seconds(from.rate_limit_seconds());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_max_packet_size()) {
+      set_max_packet_size(from.max_packet_size());
+    }
+    if (from.has_max_encoded_size()) {
+      set_max_encoded_size(from.max_encoded_size());
+    }
+    if (from.has_timeout()) {
+      set_timeout(from.timeout());
+    }
+    if (from.has_cap_balance()) {
+      set_cap_balance(from.cap_balance());
+    }
+    if (from.has_income_per_second()) {
+      set_income_per_second(from.income_per_second());
+    }
+    if (from.has_service_hash()) {
+      set_service_hash(from.service_hash());
+    }
+    if (from.has_method_id()) {
+      set_method_id(from.method_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RPCMethodConfig::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RPCMethodConfig::CopyFrom(const RPCMethodConfig& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RPCMethodConfig::IsInitialized() const {
+
+  return true;
+}
+
+void RPCMethodConfig::Swap(RPCMethodConfig* other) {
+  if (other != this) {
+    std::swap(service_name_, other->service_name_);
+    std::swap(method_name_, other->method_name_);
+    std::swap(fixed_call_cost_, other->fixed_call_cost_);
+    std::swap(fixed_packet_size_, other->fixed_packet_size_);
+    std::swap(variable_multiplier_, other->variable_multiplier_);
+    std::swap(multiplier_, other->multiplier_);
+    std::swap(rate_limit_count_, other->rate_limit_count_);
+    std::swap(rate_limit_seconds_, other->rate_limit_seconds_);
+    std::swap(max_packet_size_, other->max_packet_size_);
+    std::swap(max_encoded_size_, other->max_encoded_size_);
+    std::swap(timeout_, other->timeout_);
+    std::swap(cap_balance_, other->cap_balance_);
+    std::swap(income_per_second_, other->income_per_second_);
+    std::swap(service_hash_, other->service_hash_);
+    std::swap(method_id_, other->method_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RPCMethodConfig::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RPCMethodConfig_descriptor_;
+  metadata.reflection = RPCMethodConfig_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RPCMeterConfig::kMethodFieldNumber;
+const int RPCMeterConfig::kIncomePerSecondFieldNumber;
+const int RPCMeterConfig::kInitialBalanceFieldNumber;
+const int RPCMeterConfig::kCapBalanceFieldNumber;
+const int RPCMeterConfig::kStartupPeriodFieldNumber;
+#endif  // !_MSC_VER
+
+RPCMeterConfig::RPCMeterConfig()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.config.RPCMeterConfig)
+}
+
+void RPCMeterConfig::InitAsDefaultInstance() {
+}
+
+RPCMeterConfig::RPCMeterConfig(const RPCMeterConfig& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.config.RPCMeterConfig)
+}
+
+void RPCMeterConfig::SharedCtor() {
+  _cached_size_ = 0;
+  income_per_second_ = 1u;
+  initial_balance_ = 0u;
+  cap_balance_ = 0u;
+  startup_period_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RPCMeterConfig::~RPCMeterConfig() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.config.RPCMeterConfig)
+  SharedDtor();
+}
+
+void RPCMeterConfig::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void RPCMeterConfig::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RPCMeterConfig::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RPCMeterConfig_descriptor_;
+}
+
+const RPCMeterConfig& RPCMeterConfig::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_rpc_5fconfig_2eproto();
+  return *default_instance_;
+}
+
+RPCMeterConfig* RPCMeterConfig::default_instance_ = NULL;
+
+RPCMeterConfig* RPCMeterConfig::New() const {
+  return new RPCMeterConfig;
+}
+
+void RPCMeterConfig::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<RPCMeterConfig*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 30) {
+    ZR_(initial_balance_, startup_period_);
+    income_per_second_ = 1u;
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  method_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RPCMeterConfig::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.config.RPCMeterConfig)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.config.RPCMethodConfig method = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_method:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_method()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_method;
+        if (input->ExpectTag(16)) goto parse_income_per_second;
+        break;
+      }
+
+      // optional uint32 income_per_second = 2 [default = 1];
+      case 2: {
+        if (tag == 16) {
+         parse_income_per_second:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &income_per_second_)));
+          set_has_income_per_second();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_initial_balance;
+        break;
+      }
+
+      // optional uint32 initial_balance = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_initial_balance:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &initial_balance_)));
+          set_has_initial_balance();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_cap_balance;
+        break;
+      }
+
+      // optional uint32 cap_balance = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_cap_balance:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &cap_balance_)));
+          set_has_cap_balance();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(45)) goto parse_startup_period;
+        break;
+      }
+
+      // optional float startup_period = 5 [default = 0];
+      case 5: {
+        if (tag == 45) {
+         parse_startup_period:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>(
+                 input, &startup_period_)));
+          set_has_startup_period();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.config.RPCMeterConfig)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.config.RPCMeterConfig)
+  return false;
+#undef DO_
+}
+
+void RPCMeterConfig::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.config.RPCMeterConfig)
+  // repeated .bgs.protocol.config.RPCMethodConfig method = 1;
+  for (int i = 0; i < this->method_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->method(i), output);
+  }
+
+  // optional uint32 income_per_second = 2 [default = 1];
+  if (has_income_per_second()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->income_per_second(), output);
+  }
+
+  // optional uint32 initial_balance = 3;
+  if (has_initial_balance()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->initial_balance(), output);
+  }
+
+  // optional uint32 cap_balance = 4;
+  if (has_cap_balance()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->cap_balance(), output);
+  }
+
+  // optional float startup_period = 5 [default = 0];
+  if (has_startup_period()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFloat(5, this->startup_period(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.config.RPCMeterConfig)
+}
+
+::google::protobuf::uint8* RPCMeterConfig::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.config.RPCMeterConfig)
+  // repeated .bgs.protocol.config.RPCMethodConfig method = 1;
+  for (int i = 0; i < this->method_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->method(i), target);
+  }
+
+  // optional uint32 income_per_second = 2 [default = 1];
+  if (has_income_per_second()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->income_per_second(), target);
+  }
+
+  // optional uint32 initial_balance = 3;
+  if (has_initial_balance()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->initial_balance(), target);
+  }
+
+  // optional uint32 cap_balance = 4;
+  if (has_cap_balance()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->cap_balance(), target);
+  }
+
+  // optional float startup_period = 5 [default = 0];
+  if (has_startup_period()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(5, this->startup_period(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.config.RPCMeterConfig)
+  return target;
+}
+
+int RPCMeterConfig::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional uint32 income_per_second = 2 [default = 1];
+    if (has_income_per_second()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->income_per_second());
+    }
+
+    // optional uint32 initial_balance = 3;
+    if (has_initial_balance()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->initial_balance());
+    }
+
+    // optional uint32 cap_balance = 4;
+    if (has_cap_balance()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->cap_balance());
+    }
+
+    // optional float startup_period = 5 [default = 0];
+    if (has_startup_period()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  // repeated .bgs.protocol.config.RPCMethodConfig method = 1;
+  total_size += 1 * this->method_size();
+  for (int i = 0; i < this->method_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->method(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RPCMeterConfig::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RPCMeterConfig* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RPCMeterConfig*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RPCMeterConfig::MergeFrom(const RPCMeterConfig& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  method_.MergeFrom(from.method_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_income_per_second()) {
+      set_income_per_second(from.income_per_second());
+    }
+    if (from.has_initial_balance()) {
+      set_initial_balance(from.initial_balance());
+    }
+    if (from.has_cap_balance()) {
+      set_cap_balance(from.cap_balance());
+    }
+    if (from.has_startup_period()) {
+      set_startup_period(from.startup_period());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RPCMeterConfig::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RPCMeterConfig::CopyFrom(const RPCMeterConfig& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RPCMeterConfig::IsInitialized() const {
+
+  return true;
+}
+
+void RPCMeterConfig::Swap(RPCMeterConfig* other) {
+  if (other != this) {
+    method_.Swap(&other->method_);
+    std::swap(income_per_second_, other->income_per_second_);
+    std::swap(initial_balance_, other->initial_balance_);
+    std::swap(cap_balance_, other->cap_balance_);
+    std::swap(startup_period_, other->startup_period_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RPCMeterConfig::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RPCMeterConfig_descriptor_;
+  metadata.reflection = RPCMeterConfig_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ProtocolAlias::kServerServiceNameFieldNumber;
+const int ProtocolAlias::kClientServiceNameFieldNumber;
+#endif  // !_MSC_VER
+
+ProtocolAlias::ProtocolAlias()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.config.ProtocolAlias)
+}
+
+void ProtocolAlias::InitAsDefaultInstance() {
+}
+
+ProtocolAlias::ProtocolAlias(const ProtocolAlias& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.config.ProtocolAlias)
+}
+
+void ProtocolAlias::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  server_service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  client_service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ProtocolAlias::~ProtocolAlias() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.config.ProtocolAlias)
+  SharedDtor();
+}
+
+void ProtocolAlias::SharedDtor() {
+  if (server_service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete server_service_name_;
+  }
+  if (client_service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_service_name_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void ProtocolAlias::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ProtocolAlias::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ProtocolAlias_descriptor_;
+}
+
+const ProtocolAlias& ProtocolAlias::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_rpc_5fconfig_2eproto();
+  return *default_instance_;
+}
+
+ProtocolAlias* ProtocolAlias::default_instance_ = NULL;
+
+ProtocolAlias* ProtocolAlias::New() const {
+  return new ProtocolAlias;
+}
+
+void ProtocolAlias::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_server_service_name()) {
+      if (server_service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        server_service_name_->clear();
+      }
+    }
+    if (has_client_service_name()) {
+      if (client_service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        client_service_name_->clear();
+      }
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ProtocolAlias::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.config.ProtocolAlias)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required string server_service_name = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_server_service_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->server_service_name().data(), this->server_service_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "server_service_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_client_service_name;
+        break;
+      }
+
+      // required string client_service_name = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_client_service_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_client_service_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->client_service_name().data(), this->client_service_name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "client_service_name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.config.ProtocolAlias)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.config.ProtocolAlias)
+  return false;
+#undef DO_
+}
+
+void ProtocolAlias::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.config.ProtocolAlias)
+  // required string server_service_name = 1;
+  if (has_server_service_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->server_service_name().data(), this->server_service_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "server_service_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->server_service_name(), output);
+  }
+
+  // required string client_service_name = 2;
+  if (has_client_service_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->client_service_name().data(), this->client_service_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "client_service_name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->client_service_name(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.config.ProtocolAlias)
+}
+
+::google::protobuf::uint8* ProtocolAlias::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.config.ProtocolAlias)
+  // required string server_service_name = 1;
+  if (has_server_service_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->server_service_name().data(), this->server_service_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "server_service_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->server_service_name(), target);
+  }
+
+  // required string client_service_name = 2;
+  if (has_client_service_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->client_service_name().data(), this->client_service_name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "client_service_name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->client_service_name(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.config.ProtocolAlias)
+  return target;
+}
+
+int ProtocolAlias::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required string server_service_name = 1;
+    if (has_server_service_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->server_service_name());
+    }
+
+    // required string client_service_name = 2;
+    if (has_client_service_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->client_service_name());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ProtocolAlias::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ProtocolAlias* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ProtocolAlias*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ProtocolAlias::MergeFrom(const ProtocolAlias& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_server_service_name()) {
+      set_server_service_name(from.server_service_name());
+    }
+    if (from.has_client_service_name()) {
+      set_client_service_name(from.client_service_name());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ProtocolAlias::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ProtocolAlias::CopyFrom(const ProtocolAlias& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ProtocolAlias::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  return true;
+}
+
+void ProtocolAlias::Swap(ProtocolAlias* other) {
+  if (other != this) {
+    std::swap(server_service_name_, other->server_service_name_);
+    std::swap(client_service_name_, other->client_service_name_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ProtocolAlias::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ProtocolAlias_descriptor_;
+  metadata.reflection = ProtocolAlias_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ServiceAliases::kProtocolAliasFieldNumber;
+#endif  // !_MSC_VER
+
+ServiceAliases::ServiceAliases()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.config.ServiceAliases)
+}
+
+void ServiceAliases::InitAsDefaultInstance() {
+}
+
+ServiceAliases::ServiceAliases(const ServiceAliases& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.config.ServiceAliases)
+}
+
+void ServiceAliases::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ServiceAliases::~ServiceAliases() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.config.ServiceAliases)
+  SharedDtor();
+}
+
+void ServiceAliases::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ServiceAliases::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ServiceAliases::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ServiceAliases_descriptor_;
+}
+
+const ServiceAliases& ServiceAliases::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_rpc_5fconfig_2eproto();
+  return *default_instance_;
+}
+
+ServiceAliases* ServiceAliases::default_instance_ = NULL;
+
+ServiceAliases* ServiceAliases::New() const {
+  return new ServiceAliases;
+}
+
+void ServiceAliases::Clear() {
+  protocol_alias_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ServiceAliases::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.config.ServiceAliases)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.config.ProtocolAlias protocol_alias = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_protocol_alias:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_protocol_alias()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_protocol_alias;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.config.ServiceAliases)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.config.ServiceAliases)
+  return false;
+#undef DO_
+}
+
+void ServiceAliases::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.config.ServiceAliases)
+  // repeated .bgs.protocol.config.ProtocolAlias protocol_alias = 1;
+  for (int i = 0; i < this->protocol_alias_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->protocol_alias(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.config.ServiceAliases)
+}
+
+::google::protobuf::uint8* ServiceAliases::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.config.ServiceAliases)
+  // repeated .bgs.protocol.config.ProtocolAlias protocol_alias = 1;
+  for (int i = 0; i < this->protocol_alias_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->protocol_alias(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.config.ServiceAliases)
+  return target;
+}
+
+int ServiceAliases::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.config.ProtocolAlias protocol_alias = 1;
+  total_size += 1 * this->protocol_alias_size();
+  for (int i = 0; i < this->protocol_alias_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->protocol_alias(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ServiceAliases::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ServiceAliases* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ServiceAliases*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ServiceAliases::MergeFrom(const ServiceAliases& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  protocol_alias_.MergeFrom(from.protocol_alias_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ServiceAliases::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ServiceAliases::CopyFrom(const ServiceAliases& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ServiceAliases::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->protocol_alias())) return false;
+  return true;
+}
+
+void ServiceAliases::Swap(ServiceAliases* other) {
+  if (other != this) {
+    protocol_alias_.Swap(&other->protocol_alias_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ServiceAliases::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ServiceAliases_descriptor_;
+  metadata.reflection = ServiceAliases_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace config
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/rpc_config.pb.h b/src/server/proto/Client/rpc_config.pb.h
new file mode 100644
index 00000000000..08bc1675f57
--- /dev/null
+++ b/src/server/proto/Client/rpc_config.pb.h
@@ -0,0 +1,1388 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: rpc_config.proto
+
+#ifndef PROTOBUF_rpc_5fconfig_2eproto__INCLUDED
+#define PROTOBUF_rpc_5fconfig_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 "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace config {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_rpc_5fconfig_2eproto();
+void protobuf_AssignDesc_rpc_5fconfig_2eproto();
+void protobuf_ShutdownFile_rpc_5fconfig_2eproto();
+
+class RPCMethodConfig;
+class RPCMeterConfig;
+class ProtocolAlias;
+class ServiceAliases;
+
+// ===================================================================
+
+class TC_SHARED_API RPCMethodConfig : public ::google::protobuf::Message {
+ public:
+  RPCMethodConfig();
+  virtual ~RPCMethodConfig();
+
+  RPCMethodConfig(const RPCMethodConfig& from);
+
+  inline RPCMethodConfig& operator=(const RPCMethodConfig& 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 RPCMethodConfig& default_instance();
+
+  void Swap(RPCMethodConfig* other);
+
+  // implements Message ----------------------------------------------
+
+  RPCMethodConfig* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RPCMethodConfig& from);
+  void MergeFrom(const RPCMethodConfig& 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 service_name = 1 [deprecated = true];
+  inline bool has_service_name() const PROTOBUF_DEPRECATED;
+  inline void clear_service_name() PROTOBUF_DEPRECATED;
+  static const int kServiceNameFieldNumber = 1;
+  inline const ::std::string& service_name() const PROTOBUF_DEPRECATED;
+  inline void set_service_name(const ::std::string& value) PROTOBUF_DEPRECATED;
+  inline void set_service_name(const char* value) PROTOBUF_DEPRECATED;
+  inline void set_service_name(const char* value, size_t size) PROTOBUF_DEPRECATED;
+  inline ::std::string* mutable_service_name() PROTOBUF_DEPRECATED;
+  inline ::std::string* release_service_name() PROTOBUF_DEPRECATED;
+  inline void set_allocated_service_name(::std::string* service_name) PROTOBUF_DEPRECATED;
+
+  // optional string method_name = 2 [deprecated = true];
+  inline bool has_method_name() const PROTOBUF_DEPRECATED;
+  inline void clear_method_name() PROTOBUF_DEPRECATED;
+  static const int kMethodNameFieldNumber = 2;
+  inline const ::std::string& method_name() const PROTOBUF_DEPRECATED;
+  inline void set_method_name(const ::std::string& value) PROTOBUF_DEPRECATED;
+  inline void set_method_name(const char* value) PROTOBUF_DEPRECATED;
+  inline void set_method_name(const char* value, size_t size) PROTOBUF_DEPRECATED;
+  inline ::std::string* mutable_method_name() PROTOBUF_DEPRECATED;
+  inline ::std::string* release_method_name() PROTOBUF_DEPRECATED;
+  inline void set_allocated_method_name(::std::string* method_name) PROTOBUF_DEPRECATED;
+
+  // optional uint32 fixed_call_cost = 3 [default = 1];
+  inline bool has_fixed_call_cost() const;
+  inline void clear_fixed_call_cost();
+  static const int kFixedCallCostFieldNumber = 3;
+  inline ::google::protobuf::uint32 fixed_call_cost() const;
+  inline void set_fixed_call_cost(::google::protobuf::uint32 value);
+
+  // optional uint32 fixed_packet_size = 4 [default = 0];
+  inline bool has_fixed_packet_size() const;
+  inline void clear_fixed_packet_size();
+  static const int kFixedPacketSizeFieldNumber = 4;
+  inline ::google::protobuf::uint32 fixed_packet_size() const;
+  inline void set_fixed_packet_size(::google::protobuf::uint32 value);
+
+  // optional float variable_multiplier = 5 [default = 0];
+  inline bool has_variable_multiplier() const;
+  inline void clear_variable_multiplier();
+  static const int kVariableMultiplierFieldNumber = 5;
+  inline float variable_multiplier() const;
+  inline void set_variable_multiplier(float value);
+
+  // optional float multiplier = 6 [default = 1];
+  inline bool has_multiplier() const;
+  inline void clear_multiplier();
+  static const int kMultiplierFieldNumber = 6;
+  inline float multiplier() const;
+  inline void set_multiplier(float value);
+
+  // optional uint32 rate_limit_count = 7;
+  inline bool has_rate_limit_count() const;
+  inline void clear_rate_limit_count();
+  static const int kRateLimitCountFieldNumber = 7;
+  inline ::google::protobuf::uint32 rate_limit_count() const;
+  inline void set_rate_limit_count(::google::protobuf::uint32 value);
+
+  // optional uint32 rate_limit_seconds = 8;
+  inline bool has_rate_limit_seconds() const;
+  inline void clear_rate_limit_seconds();
+  static const int kRateLimitSecondsFieldNumber = 8;
+  inline ::google::protobuf::uint32 rate_limit_seconds() const;
+  inline void set_rate_limit_seconds(::google::protobuf::uint32 value);
+
+  // optional uint32 max_packet_size = 9;
+  inline bool has_max_packet_size() const;
+  inline void clear_max_packet_size();
+  static const int kMaxPacketSizeFieldNumber = 9;
+  inline ::google::protobuf::uint32 max_packet_size() const;
+  inline void set_max_packet_size(::google::protobuf::uint32 value);
+
+  // optional uint32 max_encoded_size = 10;
+  inline bool has_max_encoded_size() const;
+  inline void clear_max_encoded_size();
+  static const int kMaxEncodedSizeFieldNumber = 10;
+  inline ::google::protobuf::uint32 max_encoded_size() const;
+  inline void set_max_encoded_size(::google::protobuf::uint32 value);
+
+  // optional float timeout = 11;
+  inline bool has_timeout() const;
+  inline void clear_timeout();
+  static const int kTimeoutFieldNumber = 11;
+  inline float timeout() const;
+  inline void set_timeout(float value);
+
+  // optional uint32 cap_balance = 12;
+  inline bool has_cap_balance() const;
+  inline void clear_cap_balance();
+  static const int kCapBalanceFieldNumber = 12;
+  inline ::google::protobuf::uint32 cap_balance() const;
+  inline void set_cap_balance(::google::protobuf::uint32 value);
+
+  // optional float income_per_second = 13 [default = 0];
+  inline bool has_income_per_second() const;
+  inline void clear_income_per_second();
+  static const int kIncomePerSecondFieldNumber = 13;
+  inline float income_per_second() const;
+  inline void set_income_per_second(float value);
+
+  // optional uint32 service_hash = 14;
+  inline bool has_service_hash() const;
+  inline void clear_service_hash();
+  static const int kServiceHashFieldNumber = 14;
+  inline ::google::protobuf::uint32 service_hash() const;
+  inline void set_service_hash(::google::protobuf::uint32 value);
+
+  // optional uint32 method_id = 15;
+  inline bool has_method_id() const;
+  inline void clear_method_id();
+  static const int kMethodIdFieldNumber = 15;
+  inline ::google::protobuf::uint32 method_id() const;
+  inline void set_method_id(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.config.RPCMethodConfig)
+ private:
+  inline void set_has_service_name();
+  inline void clear_has_service_name();
+  inline void set_has_method_name();
+  inline void clear_has_method_name();
+  inline void set_has_fixed_call_cost();
+  inline void clear_has_fixed_call_cost();
+  inline void set_has_fixed_packet_size();
+  inline void clear_has_fixed_packet_size();
+  inline void set_has_variable_multiplier();
+  inline void clear_has_variable_multiplier();
+  inline void set_has_multiplier();
+  inline void clear_has_multiplier();
+  inline void set_has_rate_limit_count();
+  inline void clear_has_rate_limit_count();
+  inline void set_has_rate_limit_seconds();
+  inline void clear_has_rate_limit_seconds();
+  inline void set_has_max_packet_size();
+  inline void clear_has_max_packet_size();
+  inline void set_has_max_encoded_size();
+  inline void clear_has_max_encoded_size();
+  inline void set_has_timeout();
+  inline void clear_has_timeout();
+  inline void set_has_cap_balance();
+  inline void clear_has_cap_balance();
+  inline void set_has_income_per_second();
+  inline void clear_has_income_per_second();
+  inline void set_has_service_hash();
+  inline void clear_has_service_hash();
+  inline void set_has_method_id();
+  inline void clear_has_method_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* service_name_;
+  ::std::string* method_name_;
+  ::google::protobuf::uint32 fixed_call_cost_;
+  ::google::protobuf::uint32 fixed_packet_size_;
+  float variable_multiplier_;
+  float multiplier_;
+  ::google::protobuf::uint32 rate_limit_count_;
+  ::google::protobuf::uint32 rate_limit_seconds_;
+  ::google::protobuf::uint32 max_packet_size_;
+  ::google::protobuf::uint32 max_encoded_size_;
+  float timeout_;
+  ::google::protobuf::uint32 cap_balance_;
+  float income_per_second_;
+  ::google::protobuf::uint32 service_hash_;
+  ::google::protobuf::uint32 method_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_rpc_5fconfig_2eproto();
+  friend void protobuf_AssignDesc_rpc_5fconfig_2eproto();
+  friend void protobuf_ShutdownFile_rpc_5fconfig_2eproto();
+
+  void InitAsDefaultInstance();
+  static RPCMethodConfig* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API RPCMeterConfig : public ::google::protobuf::Message {
+ public:
+  RPCMeterConfig();
+  virtual ~RPCMeterConfig();
+
+  RPCMeterConfig(const RPCMeterConfig& from);
+
+  inline RPCMeterConfig& operator=(const RPCMeterConfig& 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 RPCMeterConfig& default_instance();
+
+  void Swap(RPCMeterConfig* other);
+
+  // implements Message ----------------------------------------------
+
+  RPCMeterConfig* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RPCMeterConfig& from);
+  void MergeFrom(const RPCMeterConfig& 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.config.RPCMethodConfig method = 1;
+  inline int method_size() const;
+  inline void clear_method();
+  static const int kMethodFieldNumber = 1;
+  inline const ::bgs::protocol::config::RPCMethodConfig& method(int index) const;
+  inline ::bgs::protocol::config::RPCMethodConfig* mutable_method(int index);
+  inline ::bgs::protocol::config::RPCMethodConfig* add_method();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::RPCMethodConfig >&
+      method() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::RPCMethodConfig >*
+      mutable_method();
+
+  // optional uint32 income_per_second = 2 [default = 1];
+  inline bool has_income_per_second() const;
+  inline void clear_income_per_second();
+  static const int kIncomePerSecondFieldNumber = 2;
+  inline ::google::protobuf::uint32 income_per_second() const;
+  inline void set_income_per_second(::google::protobuf::uint32 value);
+
+  // optional uint32 initial_balance = 3;
+  inline bool has_initial_balance() const;
+  inline void clear_initial_balance();
+  static const int kInitialBalanceFieldNumber = 3;
+  inline ::google::protobuf::uint32 initial_balance() const;
+  inline void set_initial_balance(::google::protobuf::uint32 value);
+
+  // optional uint32 cap_balance = 4;
+  inline bool has_cap_balance() const;
+  inline void clear_cap_balance();
+  static const int kCapBalanceFieldNumber = 4;
+  inline ::google::protobuf::uint32 cap_balance() const;
+  inline void set_cap_balance(::google::protobuf::uint32 value);
+
+  // optional float startup_period = 5 [default = 0];
+  inline bool has_startup_period() const;
+  inline void clear_startup_period();
+  static const int kStartupPeriodFieldNumber = 5;
+  inline float startup_period() const;
+  inline void set_startup_period(float value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.config.RPCMeterConfig)
+ private:
+  inline void set_has_income_per_second();
+  inline void clear_has_income_per_second();
+  inline void set_has_initial_balance();
+  inline void clear_has_initial_balance();
+  inline void set_has_cap_balance();
+  inline void clear_has_cap_balance();
+  inline void set_has_startup_period();
+  inline void clear_has_startup_period();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::RPCMethodConfig > method_;
+  ::google::protobuf::uint32 income_per_second_;
+  ::google::protobuf::uint32 initial_balance_;
+  ::google::protobuf::uint32 cap_balance_;
+  float startup_period_;
+  friend void TC_SHARED_API protobuf_AddDesc_rpc_5fconfig_2eproto();
+  friend void protobuf_AssignDesc_rpc_5fconfig_2eproto();
+  friend void protobuf_ShutdownFile_rpc_5fconfig_2eproto();
+
+  void InitAsDefaultInstance();
+  static RPCMeterConfig* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ProtocolAlias : public ::google::protobuf::Message {
+ public:
+  ProtocolAlias();
+  virtual ~ProtocolAlias();
+
+  ProtocolAlias(const ProtocolAlias& from);
+
+  inline ProtocolAlias& operator=(const ProtocolAlias& 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 ProtocolAlias& default_instance();
+
+  void Swap(ProtocolAlias* other);
+
+  // implements Message ----------------------------------------------
+
+  ProtocolAlias* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ProtocolAlias& from);
+  void MergeFrom(const ProtocolAlias& 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 string server_service_name = 1;
+  inline bool has_server_service_name() const;
+  inline void clear_server_service_name();
+  static const int kServerServiceNameFieldNumber = 1;
+  inline const ::std::string& server_service_name() const;
+  inline void set_server_service_name(const ::std::string& value);
+  inline void set_server_service_name(const char* value);
+  inline void set_server_service_name(const char* value, size_t size);
+  inline ::std::string* mutable_server_service_name();
+  inline ::std::string* release_server_service_name();
+  inline void set_allocated_server_service_name(::std::string* server_service_name);
+
+  // required string client_service_name = 2;
+  inline bool has_client_service_name() const;
+  inline void clear_client_service_name();
+  static const int kClientServiceNameFieldNumber = 2;
+  inline const ::std::string& client_service_name() const;
+  inline void set_client_service_name(const ::std::string& value);
+  inline void set_client_service_name(const char* value);
+  inline void set_client_service_name(const char* value, size_t size);
+  inline ::std::string* mutable_client_service_name();
+  inline ::std::string* release_client_service_name();
+  inline void set_allocated_client_service_name(::std::string* client_service_name);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.config.ProtocolAlias)
+ private:
+  inline void set_has_server_service_name();
+  inline void clear_has_server_service_name();
+  inline void set_has_client_service_name();
+  inline void clear_has_client_service_name();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* server_service_name_;
+  ::std::string* client_service_name_;
+  friend void TC_SHARED_API protobuf_AddDesc_rpc_5fconfig_2eproto();
+  friend void protobuf_AssignDesc_rpc_5fconfig_2eproto();
+  friend void protobuf_ShutdownFile_rpc_5fconfig_2eproto();
+
+  void InitAsDefaultInstance();
+  static ProtocolAlias* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ServiceAliases : public ::google::protobuf::Message {
+ public:
+  ServiceAliases();
+  virtual ~ServiceAliases();
+
+  ServiceAliases(const ServiceAliases& from);
+
+  inline ServiceAliases& operator=(const ServiceAliases& 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 ServiceAliases& default_instance();
+
+  void Swap(ServiceAliases* other);
+
+  // implements Message ----------------------------------------------
+
+  ServiceAliases* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ServiceAliases& from);
+  void MergeFrom(const ServiceAliases& 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.config.ProtocolAlias protocol_alias = 1;
+  inline int protocol_alias_size() const;
+  inline void clear_protocol_alias();
+  static const int kProtocolAliasFieldNumber = 1;
+  inline const ::bgs::protocol::config::ProtocolAlias& protocol_alias(int index) const;
+  inline ::bgs::protocol::config::ProtocolAlias* mutable_protocol_alias(int index);
+  inline ::bgs::protocol::config::ProtocolAlias* add_protocol_alias();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::ProtocolAlias >&
+      protocol_alias() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::ProtocolAlias >*
+      mutable_protocol_alias();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.config.ServiceAliases)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::ProtocolAlias > protocol_alias_;
+  friend void TC_SHARED_API protobuf_AddDesc_rpc_5fconfig_2eproto();
+  friend void protobuf_AssignDesc_rpc_5fconfig_2eproto();
+  friend void protobuf_ShutdownFile_rpc_5fconfig_2eproto();
+
+  void InitAsDefaultInstance();
+  static ServiceAliases* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// RPCMethodConfig
+
+// optional string service_name = 1 [deprecated = true];
+inline bool RPCMethodConfig::has_service_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RPCMethodConfig::set_has_service_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RPCMethodConfig::clear_has_service_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RPCMethodConfig::clear_service_name() {
+  if (service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    service_name_->clear();
+  }
+  clear_has_service_name();
+}
+inline const ::std::string& RPCMethodConfig::service_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.service_name)
+  return *service_name_;
+}
+inline void RPCMethodConfig::set_service_name(const ::std::string& value) {
+  set_has_service_name();
+  if (service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    service_name_ = new ::std::string;
+  }
+  service_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.service_name)
+}
+inline void RPCMethodConfig::set_service_name(const char* value) {
+  set_has_service_name();
+  if (service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    service_name_ = new ::std::string;
+  }
+  service_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.config.RPCMethodConfig.service_name)
+}
+inline void RPCMethodConfig::set_service_name(const char* value, size_t size) {
+  set_has_service_name();
+  if (service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    service_name_ = new ::std::string;
+  }
+  service_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.config.RPCMethodConfig.service_name)
+}
+inline ::std::string* RPCMethodConfig::mutable_service_name() {
+  set_has_service_name();
+  if (service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    service_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.config.RPCMethodConfig.service_name)
+  return service_name_;
+}
+inline ::std::string* RPCMethodConfig::release_service_name() {
+  clear_has_service_name();
+  if (service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = service_name_;
+    service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void RPCMethodConfig::set_allocated_service_name(::std::string* service_name) {
+  if (service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete service_name_;
+  }
+  if (service_name) {
+    set_has_service_name();
+    service_name_ = service_name;
+  } else {
+    clear_has_service_name();
+    service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.config.RPCMethodConfig.service_name)
+}
+
+// optional string method_name = 2 [deprecated = true];
+inline bool RPCMethodConfig::has_method_name() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RPCMethodConfig::set_has_method_name() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RPCMethodConfig::clear_has_method_name() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RPCMethodConfig::clear_method_name() {
+  if (method_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    method_name_->clear();
+  }
+  clear_has_method_name();
+}
+inline const ::std::string& RPCMethodConfig::method_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.method_name)
+  return *method_name_;
+}
+inline void RPCMethodConfig::set_method_name(const ::std::string& value) {
+  set_has_method_name();
+  if (method_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    method_name_ = new ::std::string;
+  }
+  method_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.method_name)
+}
+inline void RPCMethodConfig::set_method_name(const char* value) {
+  set_has_method_name();
+  if (method_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    method_name_ = new ::std::string;
+  }
+  method_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.config.RPCMethodConfig.method_name)
+}
+inline void RPCMethodConfig::set_method_name(const char* value, size_t size) {
+  set_has_method_name();
+  if (method_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    method_name_ = new ::std::string;
+  }
+  method_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.config.RPCMethodConfig.method_name)
+}
+inline ::std::string* RPCMethodConfig::mutable_method_name() {
+  set_has_method_name();
+  if (method_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    method_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.config.RPCMethodConfig.method_name)
+  return method_name_;
+}
+inline ::std::string* RPCMethodConfig::release_method_name() {
+  clear_has_method_name();
+  if (method_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = method_name_;
+    method_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void RPCMethodConfig::set_allocated_method_name(::std::string* method_name) {
+  if (method_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete method_name_;
+  }
+  if (method_name) {
+    set_has_method_name();
+    method_name_ = method_name;
+  } else {
+    clear_has_method_name();
+    method_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.config.RPCMethodConfig.method_name)
+}
+
+// optional uint32 fixed_call_cost = 3 [default = 1];
+inline bool RPCMethodConfig::has_fixed_call_cost() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void RPCMethodConfig::set_has_fixed_call_cost() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void RPCMethodConfig::clear_has_fixed_call_cost() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void RPCMethodConfig::clear_fixed_call_cost() {
+  fixed_call_cost_ = 1u;
+  clear_has_fixed_call_cost();
+}
+inline ::google::protobuf::uint32 RPCMethodConfig::fixed_call_cost() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.fixed_call_cost)
+  return fixed_call_cost_;
+}
+inline void RPCMethodConfig::set_fixed_call_cost(::google::protobuf::uint32 value) {
+  set_has_fixed_call_cost();
+  fixed_call_cost_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.fixed_call_cost)
+}
+
+// optional uint32 fixed_packet_size = 4 [default = 0];
+inline bool RPCMethodConfig::has_fixed_packet_size() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void RPCMethodConfig::set_has_fixed_packet_size() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void RPCMethodConfig::clear_has_fixed_packet_size() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void RPCMethodConfig::clear_fixed_packet_size() {
+  fixed_packet_size_ = 0u;
+  clear_has_fixed_packet_size();
+}
+inline ::google::protobuf::uint32 RPCMethodConfig::fixed_packet_size() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.fixed_packet_size)
+  return fixed_packet_size_;
+}
+inline void RPCMethodConfig::set_fixed_packet_size(::google::protobuf::uint32 value) {
+  set_has_fixed_packet_size();
+  fixed_packet_size_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.fixed_packet_size)
+}
+
+// optional float variable_multiplier = 5 [default = 0];
+inline bool RPCMethodConfig::has_variable_multiplier() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void RPCMethodConfig::set_has_variable_multiplier() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void RPCMethodConfig::clear_has_variable_multiplier() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void RPCMethodConfig::clear_variable_multiplier() {
+  variable_multiplier_ = 0;
+  clear_has_variable_multiplier();
+}
+inline float RPCMethodConfig::variable_multiplier() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.variable_multiplier)
+  return variable_multiplier_;
+}
+inline void RPCMethodConfig::set_variable_multiplier(float value) {
+  set_has_variable_multiplier();
+  variable_multiplier_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.variable_multiplier)
+}
+
+// optional float multiplier = 6 [default = 1];
+inline bool RPCMethodConfig::has_multiplier() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void RPCMethodConfig::set_has_multiplier() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void RPCMethodConfig::clear_has_multiplier() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void RPCMethodConfig::clear_multiplier() {
+  multiplier_ = 1;
+  clear_has_multiplier();
+}
+inline float RPCMethodConfig::multiplier() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.multiplier)
+  return multiplier_;
+}
+inline void RPCMethodConfig::set_multiplier(float value) {
+  set_has_multiplier();
+  multiplier_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.multiplier)
+}
+
+// optional uint32 rate_limit_count = 7;
+inline bool RPCMethodConfig::has_rate_limit_count() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void RPCMethodConfig::set_has_rate_limit_count() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void RPCMethodConfig::clear_has_rate_limit_count() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void RPCMethodConfig::clear_rate_limit_count() {
+  rate_limit_count_ = 0u;
+  clear_has_rate_limit_count();
+}
+inline ::google::protobuf::uint32 RPCMethodConfig::rate_limit_count() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.rate_limit_count)
+  return rate_limit_count_;
+}
+inline void RPCMethodConfig::set_rate_limit_count(::google::protobuf::uint32 value) {
+  set_has_rate_limit_count();
+  rate_limit_count_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.rate_limit_count)
+}
+
+// optional uint32 rate_limit_seconds = 8;
+inline bool RPCMethodConfig::has_rate_limit_seconds() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void RPCMethodConfig::set_has_rate_limit_seconds() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void RPCMethodConfig::clear_has_rate_limit_seconds() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void RPCMethodConfig::clear_rate_limit_seconds() {
+  rate_limit_seconds_ = 0u;
+  clear_has_rate_limit_seconds();
+}
+inline ::google::protobuf::uint32 RPCMethodConfig::rate_limit_seconds() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.rate_limit_seconds)
+  return rate_limit_seconds_;
+}
+inline void RPCMethodConfig::set_rate_limit_seconds(::google::protobuf::uint32 value) {
+  set_has_rate_limit_seconds();
+  rate_limit_seconds_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.rate_limit_seconds)
+}
+
+// optional uint32 max_packet_size = 9;
+inline bool RPCMethodConfig::has_max_packet_size() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void RPCMethodConfig::set_has_max_packet_size() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void RPCMethodConfig::clear_has_max_packet_size() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void RPCMethodConfig::clear_max_packet_size() {
+  max_packet_size_ = 0u;
+  clear_has_max_packet_size();
+}
+inline ::google::protobuf::uint32 RPCMethodConfig::max_packet_size() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.max_packet_size)
+  return max_packet_size_;
+}
+inline void RPCMethodConfig::set_max_packet_size(::google::protobuf::uint32 value) {
+  set_has_max_packet_size();
+  max_packet_size_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.max_packet_size)
+}
+
+// optional uint32 max_encoded_size = 10;
+inline bool RPCMethodConfig::has_max_encoded_size() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void RPCMethodConfig::set_has_max_encoded_size() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void RPCMethodConfig::clear_has_max_encoded_size() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void RPCMethodConfig::clear_max_encoded_size() {
+  max_encoded_size_ = 0u;
+  clear_has_max_encoded_size();
+}
+inline ::google::protobuf::uint32 RPCMethodConfig::max_encoded_size() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.max_encoded_size)
+  return max_encoded_size_;
+}
+inline void RPCMethodConfig::set_max_encoded_size(::google::protobuf::uint32 value) {
+  set_has_max_encoded_size();
+  max_encoded_size_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.max_encoded_size)
+}
+
+// optional float timeout = 11;
+inline bool RPCMethodConfig::has_timeout() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void RPCMethodConfig::set_has_timeout() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void RPCMethodConfig::clear_has_timeout() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void RPCMethodConfig::clear_timeout() {
+  timeout_ = 0;
+  clear_has_timeout();
+}
+inline float RPCMethodConfig::timeout() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.timeout)
+  return timeout_;
+}
+inline void RPCMethodConfig::set_timeout(float value) {
+  set_has_timeout();
+  timeout_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.timeout)
+}
+
+// optional uint32 cap_balance = 12;
+inline bool RPCMethodConfig::has_cap_balance() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void RPCMethodConfig::set_has_cap_balance() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void RPCMethodConfig::clear_has_cap_balance() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void RPCMethodConfig::clear_cap_balance() {
+  cap_balance_ = 0u;
+  clear_has_cap_balance();
+}
+inline ::google::protobuf::uint32 RPCMethodConfig::cap_balance() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.cap_balance)
+  return cap_balance_;
+}
+inline void RPCMethodConfig::set_cap_balance(::google::protobuf::uint32 value) {
+  set_has_cap_balance();
+  cap_balance_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.cap_balance)
+}
+
+// optional float income_per_second = 13 [default = 0];
+inline bool RPCMethodConfig::has_income_per_second() const {
+  return (_has_bits_[0] & 0x00001000u) != 0;
+}
+inline void RPCMethodConfig::set_has_income_per_second() {
+  _has_bits_[0] |= 0x00001000u;
+}
+inline void RPCMethodConfig::clear_has_income_per_second() {
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline void RPCMethodConfig::clear_income_per_second() {
+  income_per_second_ = 0;
+  clear_has_income_per_second();
+}
+inline float RPCMethodConfig::income_per_second() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.income_per_second)
+  return income_per_second_;
+}
+inline void RPCMethodConfig::set_income_per_second(float value) {
+  set_has_income_per_second();
+  income_per_second_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.income_per_second)
+}
+
+// optional uint32 service_hash = 14;
+inline bool RPCMethodConfig::has_service_hash() const {
+  return (_has_bits_[0] & 0x00002000u) != 0;
+}
+inline void RPCMethodConfig::set_has_service_hash() {
+  _has_bits_[0] |= 0x00002000u;
+}
+inline void RPCMethodConfig::clear_has_service_hash() {
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline void RPCMethodConfig::clear_service_hash() {
+  service_hash_ = 0u;
+  clear_has_service_hash();
+}
+inline ::google::protobuf::uint32 RPCMethodConfig::service_hash() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.service_hash)
+  return service_hash_;
+}
+inline void RPCMethodConfig::set_service_hash(::google::protobuf::uint32 value) {
+  set_has_service_hash();
+  service_hash_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.service_hash)
+}
+
+// optional uint32 method_id = 15;
+inline bool RPCMethodConfig::has_method_id() const {
+  return (_has_bits_[0] & 0x00004000u) != 0;
+}
+inline void RPCMethodConfig::set_has_method_id() {
+  _has_bits_[0] |= 0x00004000u;
+}
+inline void RPCMethodConfig::clear_has_method_id() {
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline void RPCMethodConfig::clear_method_id() {
+  method_id_ = 0u;
+  clear_has_method_id();
+}
+inline ::google::protobuf::uint32 RPCMethodConfig::method_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMethodConfig.method_id)
+  return method_id_;
+}
+inline void RPCMethodConfig::set_method_id(::google::protobuf::uint32 value) {
+  set_has_method_id();
+  method_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMethodConfig.method_id)
+}
+
+// -------------------------------------------------------------------
+
+// RPCMeterConfig
+
+// repeated .bgs.protocol.config.RPCMethodConfig method = 1;
+inline int RPCMeterConfig::method_size() const {
+  return method_.size();
+}
+inline void RPCMeterConfig::clear_method() {
+  method_.Clear();
+}
+inline const ::bgs::protocol::config::RPCMethodConfig& RPCMeterConfig::method(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMeterConfig.method)
+  return method_.Get(index);
+}
+inline ::bgs::protocol::config::RPCMethodConfig* RPCMeterConfig::mutable_method(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.config.RPCMeterConfig.method)
+  return method_.Mutable(index);
+}
+inline ::bgs::protocol::config::RPCMethodConfig* RPCMeterConfig::add_method() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.config.RPCMeterConfig.method)
+  return method_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::RPCMethodConfig >&
+RPCMeterConfig::method() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.config.RPCMeterConfig.method)
+  return method_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::RPCMethodConfig >*
+RPCMeterConfig::mutable_method() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.config.RPCMeterConfig.method)
+  return &method_;
+}
+
+// optional uint32 income_per_second = 2 [default = 1];
+inline bool RPCMeterConfig::has_income_per_second() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RPCMeterConfig::set_has_income_per_second() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RPCMeterConfig::clear_has_income_per_second() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RPCMeterConfig::clear_income_per_second() {
+  income_per_second_ = 1u;
+  clear_has_income_per_second();
+}
+inline ::google::protobuf::uint32 RPCMeterConfig::income_per_second() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMeterConfig.income_per_second)
+  return income_per_second_;
+}
+inline void RPCMeterConfig::set_income_per_second(::google::protobuf::uint32 value) {
+  set_has_income_per_second();
+  income_per_second_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMeterConfig.income_per_second)
+}
+
+// optional uint32 initial_balance = 3;
+inline bool RPCMeterConfig::has_initial_balance() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void RPCMeterConfig::set_has_initial_balance() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void RPCMeterConfig::clear_has_initial_balance() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void RPCMeterConfig::clear_initial_balance() {
+  initial_balance_ = 0u;
+  clear_has_initial_balance();
+}
+inline ::google::protobuf::uint32 RPCMeterConfig::initial_balance() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMeterConfig.initial_balance)
+  return initial_balance_;
+}
+inline void RPCMeterConfig::set_initial_balance(::google::protobuf::uint32 value) {
+  set_has_initial_balance();
+  initial_balance_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMeterConfig.initial_balance)
+}
+
+// optional uint32 cap_balance = 4;
+inline bool RPCMeterConfig::has_cap_balance() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void RPCMeterConfig::set_has_cap_balance() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void RPCMeterConfig::clear_has_cap_balance() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void RPCMeterConfig::clear_cap_balance() {
+  cap_balance_ = 0u;
+  clear_has_cap_balance();
+}
+inline ::google::protobuf::uint32 RPCMeterConfig::cap_balance() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMeterConfig.cap_balance)
+  return cap_balance_;
+}
+inline void RPCMeterConfig::set_cap_balance(::google::protobuf::uint32 value) {
+  set_has_cap_balance();
+  cap_balance_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMeterConfig.cap_balance)
+}
+
+// optional float startup_period = 5 [default = 0];
+inline bool RPCMeterConfig::has_startup_period() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void RPCMeterConfig::set_has_startup_period() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void RPCMeterConfig::clear_has_startup_period() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void RPCMeterConfig::clear_startup_period() {
+  startup_period_ = 0;
+  clear_has_startup_period();
+}
+inline float RPCMeterConfig::startup_period() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.RPCMeterConfig.startup_period)
+  return startup_period_;
+}
+inline void RPCMeterConfig::set_startup_period(float value) {
+  set_has_startup_period();
+  startup_period_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.RPCMeterConfig.startup_period)
+}
+
+// -------------------------------------------------------------------
+
+// ProtocolAlias
+
+// required string server_service_name = 1;
+inline bool ProtocolAlias::has_server_service_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ProtocolAlias::set_has_server_service_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ProtocolAlias::clear_has_server_service_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ProtocolAlias::clear_server_service_name() {
+  if (server_service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    server_service_name_->clear();
+  }
+  clear_has_server_service_name();
+}
+inline const ::std::string& ProtocolAlias::server_service_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.ProtocolAlias.server_service_name)
+  return *server_service_name_;
+}
+inline void ProtocolAlias::set_server_service_name(const ::std::string& value) {
+  set_has_server_service_name();
+  if (server_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    server_service_name_ = new ::std::string;
+  }
+  server_service_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.ProtocolAlias.server_service_name)
+}
+inline void ProtocolAlias::set_server_service_name(const char* value) {
+  set_has_server_service_name();
+  if (server_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    server_service_name_ = new ::std::string;
+  }
+  server_service_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.config.ProtocolAlias.server_service_name)
+}
+inline void ProtocolAlias::set_server_service_name(const char* value, size_t size) {
+  set_has_server_service_name();
+  if (server_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    server_service_name_ = new ::std::string;
+  }
+  server_service_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.config.ProtocolAlias.server_service_name)
+}
+inline ::std::string* ProtocolAlias::mutable_server_service_name() {
+  set_has_server_service_name();
+  if (server_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    server_service_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.config.ProtocolAlias.server_service_name)
+  return server_service_name_;
+}
+inline ::std::string* ProtocolAlias::release_server_service_name() {
+  clear_has_server_service_name();
+  if (server_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = server_service_name_;
+    server_service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ProtocolAlias::set_allocated_server_service_name(::std::string* server_service_name) {
+  if (server_service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete server_service_name_;
+  }
+  if (server_service_name) {
+    set_has_server_service_name();
+    server_service_name_ = server_service_name;
+  } else {
+    clear_has_server_service_name();
+    server_service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.config.ProtocolAlias.server_service_name)
+}
+
+// required string client_service_name = 2;
+inline bool ProtocolAlias::has_client_service_name() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ProtocolAlias::set_has_client_service_name() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ProtocolAlias::clear_has_client_service_name() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ProtocolAlias::clear_client_service_name() {
+  if (client_service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_service_name_->clear();
+  }
+  clear_has_client_service_name();
+}
+inline const ::std::string& ProtocolAlias::client_service_name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.ProtocolAlias.client_service_name)
+  return *client_service_name_;
+}
+inline void ProtocolAlias::set_client_service_name(const ::std::string& value) {
+  set_has_client_service_name();
+  if (client_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_service_name_ = new ::std::string;
+  }
+  client_service_name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.config.ProtocolAlias.client_service_name)
+}
+inline void ProtocolAlias::set_client_service_name(const char* value) {
+  set_has_client_service_name();
+  if (client_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_service_name_ = new ::std::string;
+  }
+  client_service_name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.config.ProtocolAlias.client_service_name)
+}
+inline void ProtocolAlias::set_client_service_name(const char* value, size_t size) {
+  set_has_client_service_name();
+  if (client_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_service_name_ = new ::std::string;
+  }
+  client_service_name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.config.ProtocolAlias.client_service_name)
+}
+inline ::std::string* ProtocolAlias::mutable_client_service_name() {
+  set_has_client_service_name();
+  if (client_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    client_service_name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.config.ProtocolAlias.client_service_name)
+  return client_service_name_;
+}
+inline ::std::string* ProtocolAlias::release_client_service_name() {
+  clear_has_client_service_name();
+  if (client_service_name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = client_service_name_;
+    client_service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void ProtocolAlias::set_allocated_client_service_name(::std::string* client_service_name) {
+  if (client_service_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete client_service_name_;
+  }
+  if (client_service_name) {
+    set_has_client_service_name();
+    client_service_name_ = client_service_name;
+  } else {
+    clear_has_client_service_name();
+    client_service_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.config.ProtocolAlias.client_service_name)
+}
+
+// -------------------------------------------------------------------
+
+// ServiceAliases
+
+// repeated .bgs.protocol.config.ProtocolAlias protocol_alias = 1;
+inline int ServiceAliases::protocol_alias_size() const {
+  return protocol_alias_.size();
+}
+inline void ServiceAliases::clear_protocol_alias() {
+  protocol_alias_.Clear();
+}
+inline const ::bgs::protocol::config::ProtocolAlias& ServiceAliases::protocol_alias(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.config.ServiceAliases.protocol_alias)
+  return protocol_alias_.Get(index);
+}
+inline ::bgs::protocol::config::ProtocolAlias* ServiceAliases::mutable_protocol_alias(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.config.ServiceAliases.protocol_alias)
+  return protocol_alias_.Mutable(index);
+}
+inline ::bgs::protocol::config::ProtocolAlias* ServiceAliases::add_protocol_alias() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.config.ServiceAliases.protocol_alias)
+  return protocol_alias_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::ProtocolAlias >&
+ServiceAliases::protocol_alias() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.config.ServiceAliases.protocol_alias)
+  return protocol_alias_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::config::ProtocolAlias >*
+ServiceAliases::mutable_protocol_alias() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.config.ServiceAliases.protocol_alias)
+  return &protocol_alias_;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace config
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_rpc_5fconfig_2eproto__INCLUDED
diff --git a/src/server/proto/Client/rpc_types.pb.cc b/src/server/proto/Client/rpc_types.pb.cc
new file mode 100644
index 00000000000..7eb6c798906
--- /dev/null
+++ b/src/server/proto/Client/rpc_types.pb.cc
@@ -0,0 +1,2460 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: rpc_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "rpc_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+
+namespace {
+
+const ::google::protobuf::Descriptor* NO_RESPONSE_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  NO_RESPONSE_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Address_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Address_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ProcessId_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ProcessId_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ObjectAddress_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ObjectAddress_reflection_ = NULL;
+const ::google::protobuf::Descriptor* NoData_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  NoData_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ErrorInfo_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ErrorInfo_reflection_ = NULL;
+const ::google::protobuf::Descriptor* Header_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  Header_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_rpc_5ftypes_2eproto() {
+  protobuf_AddDesc_rpc_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "rpc_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  NO_RESPONSE_descriptor_ = file->message_type(0);
+  static const int NO_RESPONSE_offsets_[1] = {
+  };
+  NO_RESPONSE_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      NO_RESPONSE_descriptor_,
+      NO_RESPONSE::default_instance_,
+      NO_RESPONSE_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NO_RESPONSE, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NO_RESPONSE, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(NO_RESPONSE));
+  Address_descriptor_ = file->message_type(1);
+  static const int Address_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Address, address_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Address, port_),
+  };
+  Address_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Address_descriptor_,
+      Address::default_instance_,
+      Address_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Address, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Address, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Address));
+  ProcessId_descriptor_ = file->message_type(2);
+  static const int ProcessId_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessId, label_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessId, epoch_),
+  };
+  ProcessId_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ProcessId_descriptor_,
+      ProcessId::default_instance_,
+      ProcessId_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessId, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ProcessId, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ProcessId));
+  ObjectAddress_descriptor_ = file->message_type(3);
+  static const int ObjectAddress_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectAddress, host_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectAddress, object_id_),
+  };
+  ObjectAddress_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ObjectAddress_descriptor_,
+      ObjectAddress::default_instance_,
+      ObjectAddress_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectAddress, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ObjectAddress, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ObjectAddress));
+  NoData_descriptor_ = file->message_type(4);
+  static const int NoData_offsets_[1] = {
+  };
+  NoData_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      NoData_descriptor_,
+      NoData::default_instance_,
+      NoData_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NoData, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(NoData, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(NoData));
+  ErrorInfo_descriptor_ = file->message_type(5);
+  static const int ErrorInfo_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorInfo, object_address_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorInfo, status_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorInfo, service_hash_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorInfo, method_id_),
+  };
+  ErrorInfo_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ErrorInfo_descriptor_,
+      ErrorInfo::default_instance_,
+      ErrorInfo_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorInfo, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ErrorInfo, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ErrorInfo));
+  Header_descriptor_ = file->message_type(6);
+  static const int Header_offsets_[11] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, service_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, method_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, token_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, object_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, size_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, status_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, error_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, timeout_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, is_response_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, forward_targets_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, service_hash_),
+  };
+  Header_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      Header_descriptor_,
+      Header::default_instance_,
+      Header_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Header, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(Header));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_rpc_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    NO_RESPONSE_descriptor_, &NO_RESPONSE::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Address_descriptor_, &Address::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ProcessId_descriptor_, &ProcessId::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ObjectAddress_descriptor_, &ObjectAddress::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    NoData_descriptor_, &NoData::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ErrorInfo_descriptor_, &ErrorInfo::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    Header_descriptor_, &Header::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_rpc_5ftypes_2eproto() {
+  delete NO_RESPONSE::default_instance_;
+  delete NO_RESPONSE_reflection_;
+  delete Address::default_instance_;
+  delete Address_reflection_;
+  delete ProcessId::default_instance_;
+  delete ProcessId_reflection_;
+  delete ObjectAddress::default_instance_;
+  delete ObjectAddress_reflection_;
+  delete NoData::default_instance_;
+  delete NoData_reflection_;
+  delete ErrorInfo::default_instance_;
+  delete ErrorInfo_reflection_;
+  delete Header::default_instance_;
+  delete Header_reflection_;
+}
+
+void protobuf_AddDesc_rpc_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2fmethod_5foptions_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2fservice_5foptions_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\017rpc_types.proto\022\014bgs.protocol\032&global_"
+    "extensions/method_options.proto\032\'global_"
+    "extensions/service_options.proto\032%global"
+    "_extensions/field_options.proto\"\r\n\013NO_RE"
+    "SPONSE\"(\n\007Address\022\017\n\007address\030\001 \002(\t\022\014\n\004po"
+    "rt\030\002 \001(\r\")\n\tProcessId\022\r\n\005label\030\001 \002(\r\022\r\n\005"
+    "epoch\030\002 \002(\r\"L\n\rObjectAddress\022%\n\004host\030\001 \002"
+    "(\0132\027.bgs.protocol.ProcessId\022\024\n\tobject_id"
+    "\030\002 \001(\004:\0010\"\010\n\006NoData\"y\n\tErrorInfo\0223\n\016obje"
+    "ct_address\030\001 \002(\0132\033.bgs.protocol.ObjectAd"
+    "dress\022\016\n\006status\030\002 \002(\r\022\024\n\014service_hash\030\003 "
+    "\002(\r\022\021\n\tmethod_id\030\004 \002(\r\"\216\002\n\006Header\022\022\n\nser"
+    "vice_id\030\001 \002(\r\022\021\n\tmethod_id\030\002 \001(\r\022\r\n\005toke"
+    "n\030\003 \002(\r\022\024\n\tobject_id\030\004 \001(\004:\0010\022\017\n\004size\030\005 "
+    "\001(\r:\0010\022\021\n\006status\030\006 \001(\r:\0010\022&\n\005error\030\007 \003(\013"
+    "2\027.bgs.protocol.ErrorInfo\022\017\n\007timeout\030\010 \001"
+    "(\004\022\023\n\013is_response\030\t \001(\010\0220\n\017forward_targe"
+    "ts\030\n \003(\0132\027.bgs.protocol.ProcessId\022\024\n\014ser"
+    "vice_hash\030\013 \001(\007B\033\n\rbnet.protocolB\010RpcPro"
+    "toH\001P\000P\001P\002", 770);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "rpc_types.proto", &protobuf_RegisterTypes);
+  NO_RESPONSE::default_instance_ = new NO_RESPONSE();
+  Address::default_instance_ = new Address();
+  ProcessId::default_instance_ = new ProcessId();
+  ObjectAddress::default_instance_ = new ObjectAddress();
+  NoData::default_instance_ = new NoData();
+  ErrorInfo::default_instance_ = new ErrorInfo();
+  Header::default_instance_ = new Header();
+  NO_RESPONSE::default_instance_->InitAsDefaultInstance();
+  Address::default_instance_->InitAsDefaultInstance();
+  ProcessId::default_instance_->InitAsDefaultInstance();
+  ObjectAddress::default_instance_->InitAsDefaultInstance();
+  NoData::default_instance_->InitAsDefaultInstance();
+  ErrorInfo::default_instance_->InitAsDefaultInstance();
+  Header::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_rpc_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_rpc_5ftypes_2eproto {
+  StaticDescriptorInitializer_rpc_5ftypes_2eproto() {
+    protobuf_AddDesc_rpc_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_rpc_5ftypes_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+#endif  // !_MSC_VER
+
+NO_RESPONSE::NO_RESPONSE()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.NO_RESPONSE)
+}
+
+void NO_RESPONSE::InitAsDefaultInstance() {
+}
+
+NO_RESPONSE::NO_RESPONSE(const NO_RESPONSE& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.NO_RESPONSE)
+}
+
+void NO_RESPONSE::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+NO_RESPONSE::~NO_RESPONSE() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.NO_RESPONSE)
+  SharedDtor();
+}
+
+void NO_RESPONSE::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void NO_RESPONSE::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* NO_RESPONSE::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return NO_RESPONSE_descriptor_;
+}
+
+const NO_RESPONSE& NO_RESPONSE::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_rpc_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+NO_RESPONSE* NO_RESPONSE::default_instance_ = NULL;
+
+NO_RESPONSE* NO_RESPONSE::New() const {
+  return new NO_RESPONSE;
+}
+
+void NO_RESPONSE::Clear() {
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool NO_RESPONSE::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.NO_RESPONSE)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+  handle_unusual:
+    if (tag == 0 ||
+        ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+      goto success;
+    }
+    DO_(::google::protobuf::internal::WireFormat::SkipField(
+          input, tag, mutable_unknown_fields()));
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.NO_RESPONSE)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.NO_RESPONSE)
+  return false;
+#undef DO_
+}
+
+void NO_RESPONSE::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.NO_RESPONSE)
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.NO_RESPONSE)
+}
+
+::google::protobuf::uint8* NO_RESPONSE::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.NO_RESPONSE)
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.NO_RESPONSE)
+  return target;
+}
+
+int NO_RESPONSE::ByteSize() const {
+  int total_size = 0;
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void NO_RESPONSE::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const NO_RESPONSE* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const NO_RESPONSE*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void NO_RESPONSE::MergeFrom(const NO_RESPONSE& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void NO_RESPONSE::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void NO_RESPONSE::CopyFrom(const NO_RESPONSE& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool NO_RESPONSE::IsInitialized() const {
+
+  return true;
+}
+
+void NO_RESPONSE::Swap(NO_RESPONSE* other) {
+  if (other != this) {
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata NO_RESPONSE::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = NO_RESPONSE_descriptor_;
+  metadata.reflection = NO_RESPONSE_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Address::kAddressFieldNumber;
+const int Address::kPortFieldNumber;
+#endif  // !_MSC_VER
+
+Address::Address()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.Address)
+}
+
+void Address::InitAsDefaultInstance() {
+}
+
+Address::Address(const Address& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.Address)
+}
+
+void Address::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  port_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Address::~Address() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.Address)
+  SharedDtor();
+}
+
+void Address::SharedDtor() {
+  if (address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete address_;
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void Address::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Address::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Address_descriptor_;
+}
+
+const Address& Address::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_rpc_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Address* Address::default_instance_ = NULL;
+
+Address* Address::New() const {
+  return new Address;
+}
+
+void Address::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_address()) {
+      if (address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        address_->clear();
+      }
+    }
+    port_ = 0u;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Address::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.Address)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required string address = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_address()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->address().data(), this->address().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "address");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_port;
+        break;
+      }
+
+      // optional uint32 port = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_port:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &port_)));
+          set_has_port();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.Address)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.Address)
+  return false;
+#undef DO_
+}
+
+void Address::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.Address)
+  // required string address = 1;
+  if (has_address()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->address().data(), this->address().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "address");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      1, this->address(), output);
+  }
+
+  // optional uint32 port = 2;
+  if (has_port()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->port(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.Address)
+}
+
+::google::protobuf::uint8* Address::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Address)
+  // required string address = 1;
+  if (has_address()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->address().data(), this->address().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "address");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        1, this->address(), target);
+  }
+
+  // optional uint32 port = 2;
+  if (has_port()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->port(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Address)
+  return target;
+}
+
+int Address::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required string address = 1;
+    if (has_address()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->address());
+    }
+
+    // optional uint32 port = 2;
+    if (has_port()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->port());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Address::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Address* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Address*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Address::MergeFrom(const Address& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_address()) {
+      set_address(from.address());
+    }
+    if (from.has_port()) {
+      set_port(from.port());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Address::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Address::CopyFrom(const Address& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Address::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  return true;
+}
+
+void Address::Swap(Address* other) {
+  if (other != this) {
+    std::swap(address_, other->address_);
+    std::swap(port_, other->port_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Address::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Address_descriptor_;
+  metadata.reflection = Address_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ProcessId::kLabelFieldNumber;
+const int ProcessId::kEpochFieldNumber;
+#endif  // !_MSC_VER
+
+ProcessId::ProcessId()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.ProcessId)
+}
+
+void ProcessId::InitAsDefaultInstance() {
+}
+
+ProcessId::ProcessId(const ProcessId& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.ProcessId)
+}
+
+void ProcessId::SharedCtor() {
+  _cached_size_ = 0;
+  label_ = 0u;
+  epoch_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ProcessId::~ProcessId() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.ProcessId)
+  SharedDtor();
+}
+
+void ProcessId::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ProcessId::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ProcessId::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ProcessId_descriptor_;
+}
+
+const ProcessId& ProcessId::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_rpc_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ProcessId* ProcessId::default_instance_ = NULL;
+
+ProcessId* ProcessId::New() const {
+  return new ProcessId;
+}
+
+void ProcessId::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ProcessId*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  ZR_(label_, epoch_);
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ProcessId::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.ProcessId)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required uint32 label = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &label_)));
+          set_has_label();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_epoch;
+        break;
+      }
+
+      // required uint32 epoch = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_epoch:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &epoch_)));
+          set_has_epoch();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.ProcessId)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.ProcessId)
+  return false;
+#undef DO_
+}
+
+void ProcessId::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.ProcessId)
+  // required uint32 label = 1;
+  if (has_label()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->label(), output);
+  }
+
+  // required uint32 epoch = 2;
+  if (has_epoch()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->epoch(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.ProcessId)
+}
+
+::google::protobuf::uint8* ProcessId::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.ProcessId)
+  // required uint32 label = 1;
+  if (has_label()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->label(), target);
+  }
+
+  // required uint32 epoch = 2;
+  if (has_epoch()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->epoch(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.ProcessId)
+  return target;
+}
+
+int ProcessId::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 label = 1;
+    if (has_label()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->label());
+    }
+
+    // required uint32 epoch = 2;
+    if (has_epoch()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->epoch());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ProcessId::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ProcessId* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ProcessId*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ProcessId::MergeFrom(const ProcessId& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_label()) {
+      set_label(from.label());
+    }
+    if (from.has_epoch()) {
+      set_epoch(from.epoch());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ProcessId::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ProcessId::CopyFrom(const ProcessId& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ProcessId::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
+
+  return true;
+}
+
+void ProcessId::Swap(ProcessId* other) {
+  if (other != this) {
+    std::swap(label_, other->label_);
+    std::swap(epoch_, other->epoch_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ProcessId::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ProcessId_descriptor_;
+  metadata.reflection = ProcessId_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ObjectAddress::kHostFieldNumber;
+const int ObjectAddress::kObjectIdFieldNumber;
+#endif  // !_MSC_VER
+
+ObjectAddress::ObjectAddress()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.ObjectAddress)
+}
+
+void ObjectAddress::InitAsDefaultInstance() {
+  host_ = const_cast< ::bgs::protocol::ProcessId*>(&::bgs::protocol::ProcessId::default_instance());
+}
+
+ObjectAddress::ObjectAddress(const ObjectAddress& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.ObjectAddress)
+}
+
+void ObjectAddress::SharedCtor() {
+  _cached_size_ = 0;
+  host_ = NULL;
+  object_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ObjectAddress::~ObjectAddress() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.ObjectAddress)
+  SharedDtor();
+}
+
+void ObjectAddress::SharedDtor() {
+  if (this != default_instance_) {
+    delete host_;
+  }
+}
+
+void ObjectAddress::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ObjectAddress::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ObjectAddress_descriptor_;
+}
+
+const ObjectAddress& ObjectAddress::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_rpc_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ObjectAddress* ObjectAddress::default_instance_ = NULL;
+
+ObjectAddress* ObjectAddress::New() const {
+  return new ObjectAddress;
+}
+
+void ObjectAddress::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_host()) {
+      if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+    }
+    object_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ObjectAddress::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.ObjectAddress)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.ProcessId host = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_host()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_object_id;
+        break;
+      }
+
+      // optional uint64 object_id = 2 [default = 0];
+      case 2: {
+        if (tag == 16) {
+         parse_object_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &object_id_)));
+          set_has_object_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.ObjectAddress)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.ObjectAddress)
+  return false;
+#undef DO_
+}
+
+void ObjectAddress::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.ObjectAddress)
+  // required .bgs.protocol.ProcessId host = 1;
+  if (has_host()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->host(), output);
+  }
+
+  // optional uint64 object_id = 2 [default = 0];
+  if (has_object_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->object_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.ObjectAddress)
+}
+
+::google::protobuf::uint8* ObjectAddress::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.ObjectAddress)
+  // required .bgs.protocol.ProcessId host = 1;
+  if (has_host()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->host(), target);
+  }
+
+  // optional uint64 object_id = 2 [default = 0];
+  if (has_object_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->object_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.ObjectAddress)
+  return target;
+}
+
+int ObjectAddress::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.ProcessId host = 1;
+    if (has_host()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->host());
+    }
+
+    // optional uint64 object_id = 2 [default = 0];
+    if (has_object_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->object_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ObjectAddress::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ObjectAddress* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ObjectAddress*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ObjectAddress::MergeFrom(const ObjectAddress& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_host()) {
+      mutable_host()->::bgs::protocol::ProcessId::MergeFrom(from.host());
+    }
+    if (from.has_object_id()) {
+      set_object_id(from.object_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ObjectAddress::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ObjectAddress::CopyFrom(const ObjectAddress& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ObjectAddress::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_host()) {
+    if (!this->host().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ObjectAddress::Swap(ObjectAddress* other) {
+  if (other != this) {
+    std::swap(host_, other->host_);
+    std::swap(object_id_, other->object_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ObjectAddress::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ObjectAddress_descriptor_;
+  metadata.reflection = ObjectAddress_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+#endif  // !_MSC_VER
+
+NoData::NoData()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.NoData)
+}
+
+void NoData::InitAsDefaultInstance() {
+}
+
+NoData::NoData(const NoData& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.NoData)
+}
+
+void NoData::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+NoData::~NoData() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.NoData)
+  SharedDtor();
+}
+
+void NoData::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void NoData::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* NoData::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return NoData_descriptor_;
+}
+
+const NoData& NoData::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_rpc_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+NoData* NoData::default_instance_ = NULL;
+
+NoData* NoData::New() const {
+  return new NoData;
+}
+
+void NoData::Clear() {
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool NoData::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.NoData)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+  handle_unusual:
+    if (tag == 0 ||
+        ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+        ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+      goto success;
+    }
+    DO_(::google::protobuf::internal::WireFormat::SkipField(
+          input, tag, mutable_unknown_fields()));
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.NoData)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.NoData)
+  return false;
+#undef DO_
+}
+
+void NoData::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.NoData)
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.NoData)
+}
+
+::google::protobuf::uint8* NoData::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.NoData)
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.NoData)
+  return target;
+}
+
+int NoData::ByteSize() const {
+  int total_size = 0;
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void NoData::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const NoData* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const NoData*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void NoData::MergeFrom(const NoData& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void NoData::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void NoData::CopyFrom(const NoData& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool NoData::IsInitialized() const {
+
+  return true;
+}
+
+void NoData::Swap(NoData* other) {
+  if (other != this) {
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata NoData::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = NoData_descriptor_;
+  metadata.reflection = NoData_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ErrorInfo::kObjectAddressFieldNumber;
+const int ErrorInfo::kStatusFieldNumber;
+const int ErrorInfo::kServiceHashFieldNumber;
+const int ErrorInfo::kMethodIdFieldNumber;
+#endif  // !_MSC_VER
+
+ErrorInfo::ErrorInfo()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.ErrorInfo)
+}
+
+void ErrorInfo::InitAsDefaultInstance() {
+  object_address_ = const_cast< ::bgs::protocol::ObjectAddress*>(&::bgs::protocol::ObjectAddress::default_instance());
+}
+
+ErrorInfo::ErrorInfo(const ErrorInfo& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.ErrorInfo)
+}
+
+void ErrorInfo::SharedCtor() {
+  _cached_size_ = 0;
+  object_address_ = NULL;
+  status_ = 0u;
+  service_hash_ = 0u;
+  method_id_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ErrorInfo::~ErrorInfo() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.ErrorInfo)
+  SharedDtor();
+}
+
+void ErrorInfo::SharedDtor() {
+  if (this != default_instance_) {
+    delete object_address_;
+  }
+}
+
+void ErrorInfo::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ErrorInfo::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ErrorInfo_descriptor_;
+}
+
+const ErrorInfo& ErrorInfo::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_rpc_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+ErrorInfo* ErrorInfo::default_instance_ = NULL;
+
+ErrorInfo* ErrorInfo::New() const {
+  return new ErrorInfo;
+}
+
+void ErrorInfo::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<ErrorInfo*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 15) {
+    ZR_(status_, method_id_);
+    if (has_object_address()) {
+      if (object_address_ != NULL) object_address_->::bgs::protocol::ObjectAddress::Clear();
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ErrorInfo::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.ErrorInfo)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.ObjectAddress object_address = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_object_address()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_status;
+        break;
+      }
+
+      // required uint32 status = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_status:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &status_)));
+          set_has_status();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_service_hash;
+        break;
+      }
+
+      // required uint32 service_hash = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_service_hash:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &service_hash_)));
+          set_has_service_hash();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_method_id;
+        break;
+      }
+
+      // required uint32 method_id = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_method_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &method_id_)));
+          set_has_method_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.ErrorInfo)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.ErrorInfo)
+  return false;
+#undef DO_
+}
+
+void ErrorInfo::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.ErrorInfo)
+  // required .bgs.protocol.ObjectAddress object_address = 1;
+  if (has_object_address()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->object_address(), output);
+  }
+
+  // required uint32 status = 2;
+  if (has_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->status(), output);
+  }
+
+  // required uint32 service_hash = 3;
+  if (has_service_hash()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->service_hash(), output);
+  }
+
+  // required uint32 method_id = 4;
+  if (has_method_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->method_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.ErrorInfo)
+}
+
+::google::protobuf::uint8* ErrorInfo::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.ErrorInfo)
+  // required .bgs.protocol.ObjectAddress object_address = 1;
+  if (has_object_address()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->object_address(), target);
+  }
+
+  // required uint32 status = 2;
+  if (has_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->status(), target);
+  }
+
+  // required uint32 service_hash = 3;
+  if (has_service_hash()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->service_hash(), target);
+  }
+
+  // required uint32 method_id = 4;
+  if (has_method_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->method_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.ErrorInfo)
+  return target;
+}
+
+int ErrorInfo::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.ObjectAddress object_address = 1;
+    if (has_object_address()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->object_address());
+    }
+
+    // required uint32 status = 2;
+    if (has_status()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->status());
+    }
+
+    // required uint32 service_hash = 3;
+    if (has_service_hash()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->service_hash());
+    }
+
+    // required uint32 method_id = 4;
+    if (has_method_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->method_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ErrorInfo::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ErrorInfo* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ErrorInfo*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ErrorInfo::MergeFrom(const ErrorInfo& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_object_address()) {
+      mutable_object_address()->::bgs::protocol::ObjectAddress::MergeFrom(from.object_address());
+    }
+    if (from.has_status()) {
+      set_status(from.status());
+    }
+    if (from.has_service_hash()) {
+      set_service_hash(from.service_hash());
+    }
+    if (from.has_method_id()) {
+      set_method_id(from.method_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ErrorInfo::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ErrorInfo::CopyFrom(const ErrorInfo& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ErrorInfo::IsInitialized() const {
+  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;
+
+  if (has_object_address()) {
+    if (!this->object_address().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ErrorInfo::Swap(ErrorInfo* other) {
+  if (other != this) {
+    std::swap(object_address_, other->object_address_);
+    std::swap(status_, other->status_);
+    std::swap(service_hash_, other->service_hash_);
+    std::swap(method_id_, other->method_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ErrorInfo::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ErrorInfo_descriptor_;
+  metadata.reflection = ErrorInfo_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int Header::kServiceIdFieldNumber;
+const int Header::kMethodIdFieldNumber;
+const int Header::kTokenFieldNumber;
+const int Header::kObjectIdFieldNumber;
+const int Header::kSizeFieldNumber;
+const int Header::kStatusFieldNumber;
+const int Header::kErrorFieldNumber;
+const int Header::kTimeoutFieldNumber;
+const int Header::kIsResponseFieldNumber;
+const int Header::kForwardTargetsFieldNumber;
+const int Header::kServiceHashFieldNumber;
+#endif  // !_MSC_VER
+
+Header::Header()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.Header)
+}
+
+void Header::InitAsDefaultInstance() {
+}
+
+Header::Header(const Header& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.Header)
+}
+
+void Header::SharedCtor() {
+  _cached_size_ = 0;
+  service_id_ = 0u;
+  method_id_ = 0u;
+  token_ = 0u;
+  object_id_ = GOOGLE_ULONGLONG(0);
+  size_ = 0u;
+  status_ = 0u;
+  timeout_ = GOOGLE_ULONGLONG(0);
+  is_response_ = false;
+  service_hash_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+Header::~Header() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.Header)
+  SharedDtor();
+}
+
+void Header::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void Header::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* Header::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return Header_descriptor_;
+}
+
+const Header& Header::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_rpc_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+Header* Header::default_instance_ = NULL;
+
+Header* Header::New() const {
+  return new Header;
+}
+
+void Header::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<Header*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 191) {
+    ZR_(service_id_, size_);
+    status_ = 0u;
+    timeout_ = GOOGLE_ULONGLONG(0);
+  }
+  if (_has_bits_[8 / 32] & 1280) {
+    is_response_ = false;
+    service_hash_ = 0u;
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  error_.Clear();
+  forward_targets_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool Header::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.Header)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required uint32 service_id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &service_id_)));
+          set_has_service_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_method_id;
+        break;
+      }
+
+      // optional uint32 method_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_method_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &method_id_)));
+          set_has_method_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_token;
+        break;
+      }
+
+      // required uint32 token = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_token:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &token_)));
+          set_has_token();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_object_id;
+        break;
+      }
+
+      // optional uint64 object_id = 4 [default = 0];
+      case 4: {
+        if (tag == 32) {
+         parse_object_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &object_id_)));
+          set_has_object_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(40)) goto parse_size;
+        break;
+      }
+
+      // optional uint32 size = 5 [default = 0];
+      case 5: {
+        if (tag == 40) {
+         parse_size:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &size_)));
+          set_has_size();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(48)) goto parse_status;
+        break;
+      }
+
+      // optional uint32 status = 6 [default = 0];
+      case 6: {
+        if (tag == 48) {
+         parse_status:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &status_)));
+          set_has_status();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_error;
+        break;
+      }
+
+      // repeated .bgs.protocol.ErrorInfo error = 7;
+      case 7: {
+        if (tag == 58) {
+         parse_error:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_error()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(58)) goto parse_error;
+        if (input->ExpectTag(64)) goto parse_timeout;
+        break;
+      }
+
+      // optional uint64 timeout = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_timeout:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &timeout_)));
+          set_has_timeout();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(72)) goto parse_is_response;
+        break;
+      }
+
+      // optional bool is_response = 9;
+      case 9: {
+        if (tag == 72) {
+         parse_is_response:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &is_response_)));
+          set_has_is_response();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_forward_targets;
+        break;
+      }
+
+      // repeated .bgs.protocol.ProcessId forward_targets = 10;
+      case 10: {
+        if (tag == 82) {
+         parse_forward_targets:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_forward_targets()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(82)) goto parse_forward_targets;
+        if (input->ExpectTag(93)) goto parse_service_hash;
+        break;
+      }
+
+      // optional fixed32 service_hash = 11;
+      case 11: {
+        if (tag == 93) {
+         parse_service_hash:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &service_hash_)));
+          set_has_service_hash();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.Header)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.Header)
+  return false;
+#undef DO_
+}
+
+void Header::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.Header)
+  // required uint32 service_id = 1;
+  if (has_service_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->service_id(), output);
+  }
+
+  // optional uint32 method_id = 2;
+  if (has_method_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->method_id(), output);
+  }
+
+  // required uint32 token = 3;
+  if (has_token()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->token(), output);
+  }
+
+  // optional uint64 object_id = 4 [default = 0];
+  if (has_object_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->object_id(), output);
+  }
+
+  // optional uint32 size = 5 [default = 0];
+  if (has_size()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->size(), output);
+  }
+
+  // optional uint32 status = 6 [default = 0];
+  if (has_status()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->status(), output);
+  }
+
+  // repeated .bgs.protocol.ErrorInfo error = 7;
+  for (int i = 0; i < this->error_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      7, this->error(i), output);
+  }
+
+  // optional uint64 timeout = 8;
+  if (has_timeout()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(8, this->timeout(), output);
+  }
+
+  // optional bool is_response = 9;
+  if (has_is_response()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(9, this->is_response(), output);
+  }
+
+  // repeated .bgs.protocol.ProcessId forward_targets = 10;
+  for (int i = 0; i < this->forward_targets_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      10, this->forward_targets(i), output);
+  }
+
+  // optional fixed32 service_hash = 11;
+  if (has_service_hash()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(11, this->service_hash(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.Header)
+}
+
+::google::protobuf::uint8* Header::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.Header)
+  // required uint32 service_id = 1;
+  if (has_service_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->service_id(), target);
+  }
+
+  // optional uint32 method_id = 2;
+  if (has_method_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->method_id(), target);
+  }
+
+  // required uint32 token = 3;
+  if (has_token()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->token(), target);
+  }
+
+  // optional uint64 object_id = 4 [default = 0];
+  if (has_object_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->object_id(), target);
+  }
+
+  // optional uint32 size = 5 [default = 0];
+  if (has_size()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->size(), target);
+  }
+
+  // optional uint32 status = 6 [default = 0];
+  if (has_status()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->status(), target);
+  }
+
+  // repeated .bgs.protocol.ErrorInfo error = 7;
+  for (int i = 0; i < this->error_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        7, this->error(i), target);
+  }
+
+  // optional uint64 timeout = 8;
+  if (has_timeout()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(8, this->timeout(), target);
+  }
+
+  // optional bool is_response = 9;
+  if (has_is_response()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(9, this->is_response(), target);
+  }
+
+  // repeated .bgs.protocol.ProcessId forward_targets = 10;
+  for (int i = 0; i < this->forward_targets_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        10, this->forward_targets(i), target);
+  }
+
+  // optional fixed32 service_hash = 11;
+  if (has_service_hash()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(11, this->service_hash(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.Header)
+  return target;
+}
+
+int Header::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required uint32 service_id = 1;
+    if (has_service_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->service_id());
+    }
+
+    // optional uint32 method_id = 2;
+    if (has_method_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->method_id());
+    }
+
+    // required uint32 token = 3;
+    if (has_token()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->token());
+    }
+
+    // optional uint64 object_id = 4 [default = 0];
+    if (has_object_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->object_id());
+    }
+
+    // optional uint32 size = 5 [default = 0];
+    if (has_size()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->size());
+    }
+
+    // optional uint32 status = 6 [default = 0];
+    if (has_status()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->status());
+    }
+
+    // optional uint64 timeout = 8;
+    if (has_timeout()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->timeout());
+    }
+
+  }
+  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    // optional bool is_response = 9;
+    if (has_is_response()) {
+      total_size += 1 + 1;
+    }
+
+    // optional fixed32 service_hash = 11;
+    if (has_service_hash()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  // repeated .bgs.protocol.ErrorInfo error = 7;
+  total_size += 1 * this->error_size();
+  for (int i = 0; i < this->error_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->error(i));
+  }
+
+  // repeated .bgs.protocol.ProcessId forward_targets = 10;
+  total_size += 1 * this->forward_targets_size();
+  for (int i = 0; i < this->forward_targets_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->forward_targets(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void Header::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const Header* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const Header*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void Header::MergeFrom(const Header& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  error_.MergeFrom(from.error_);
+  forward_targets_.MergeFrom(from.forward_targets_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_service_id()) {
+      set_service_id(from.service_id());
+    }
+    if (from.has_method_id()) {
+      set_method_id(from.method_id());
+    }
+    if (from.has_token()) {
+      set_token(from.token());
+    }
+    if (from.has_object_id()) {
+      set_object_id(from.object_id());
+    }
+    if (from.has_size()) {
+      set_size(from.size());
+    }
+    if (from.has_status()) {
+      set_status(from.status());
+    }
+    if (from.has_timeout()) {
+      set_timeout(from.timeout());
+    }
+  }
+  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
+    if (from.has_is_response()) {
+      set_is_response(from.is_response());
+    }
+    if (from.has_service_hash()) {
+      set_service_hash(from.service_hash());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void Header::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void Header::CopyFrom(const Header& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool Header::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false;
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->error())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->forward_targets())) return false;
+  return true;
+}
+
+void Header::Swap(Header* other) {
+  if (other != this) {
+    std::swap(service_id_, other->service_id_);
+    std::swap(method_id_, other->method_id_);
+    std::swap(token_, other->token_);
+    std::swap(object_id_, other->object_id_);
+    std::swap(size_, other->size_);
+    std::swap(status_, other->status_);
+    error_.Swap(&other->error_);
+    std::swap(timeout_, other->timeout_);
+    std::swap(is_response_, other->is_response_);
+    forward_targets_.Swap(&other->forward_targets_);
+    std::swap(service_hash_, other->service_hash_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata Header::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = Header_descriptor_;
+  metadata.reflection = Header_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/rpc_types.pb.h b/src/server/proto/Client/rpc_types.pb.h
new file mode 100644
index 00000000000..242947a32d1
--- /dev/null
+++ b/src/server/proto/Client/rpc_types.pb.h
@@ -0,0 +1,1410 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: rpc_types.proto
+
+#ifndef PROTOBUF_rpc_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_rpc_5ftypes_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 "global_extensions/method_options.pb.h"  // IWYU pragma: export
+#include "global_extensions/service_options.pb.h"  // IWYU pragma: export
+#include "global_extensions/field_options.pb.h"  // IWYU pragma: export
+#include "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_rpc_5ftypes_2eproto();
+void protobuf_AssignDesc_rpc_5ftypes_2eproto();
+void protobuf_ShutdownFile_rpc_5ftypes_2eproto();
+
+class NO_RESPONSE;
+class Address;
+class ProcessId;
+class ObjectAddress;
+class NoData;
+class ErrorInfo;
+class Header;
+
+// ===================================================================
+
+class TC_SHARED_API NO_RESPONSE : public ::google::protobuf::Message {
+ public:
+  NO_RESPONSE();
+  virtual ~NO_RESPONSE();
+
+  NO_RESPONSE(const NO_RESPONSE& from);
+
+  inline NO_RESPONSE& operator=(const NO_RESPONSE& 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 NO_RESPONSE& default_instance();
+
+  void Swap(NO_RESPONSE* other);
+
+  // implements Message ----------------------------------------------
+
+  NO_RESPONSE* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const NO_RESPONSE& from);
+  void MergeFrom(const NO_RESPONSE& 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 -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.NO_RESPONSE)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  friend void TC_SHARED_API protobuf_AddDesc_rpc_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_rpc_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_rpc_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static NO_RESPONSE* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API Address : public ::google::protobuf::Message {
+ public:
+  Address();
+  virtual ~Address();
+
+  Address(const Address& from);
+
+  inline Address& operator=(const Address& 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 Address& default_instance();
+
+  void Swap(Address* other);
+
+  // implements Message ----------------------------------------------
+
+  Address* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Address& from);
+  void MergeFrom(const Address& 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 string address = 1;
+  inline bool has_address() const;
+  inline void clear_address();
+  static const int kAddressFieldNumber = 1;
+  inline const ::std::string& address() const;
+  inline void set_address(const ::std::string& value);
+  inline void set_address(const char* value);
+  inline void set_address(const char* value, size_t size);
+  inline ::std::string* mutable_address();
+  inline ::std::string* release_address();
+  inline void set_allocated_address(::std::string* address);
+
+  // optional uint32 port = 2;
+  inline bool has_port() const;
+  inline void clear_port();
+  static const int kPortFieldNumber = 2;
+  inline ::google::protobuf::uint32 port() const;
+  inline void set_port(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.Address)
+ private:
+  inline void set_has_address();
+  inline void clear_has_address();
+  inline void set_has_port();
+  inline void clear_has_port();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::std::string* address_;
+  ::google::protobuf::uint32 port_;
+  friend void TC_SHARED_API protobuf_AddDesc_rpc_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_rpc_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_rpc_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Address* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ProcessId : public ::google::protobuf::Message {
+ public:
+  ProcessId();
+  virtual ~ProcessId();
+
+  ProcessId(const ProcessId& from);
+
+  inline ProcessId& operator=(const ProcessId& 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 ProcessId& default_instance();
+
+  void Swap(ProcessId* other);
+
+  // implements Message ----------------------------------------------
+
+  ProcessId* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ProcessId& from);
+  void MergeFrom(const ProcessId& 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 label = 1;
+  inline bool has_label() const;
+  inline void clear_label();
+  static const int kLabelFieldNumber = 1;
+  inline ::google::protobuf::uint32 label() const;
+  inline void set_label(::google::protobuf::uint32 value);
+
+  // required uint32 epoch = 2;
+  inline bool has_epoch() const;
+  inline void clear_epoch();
+  static const int kEpochFieldNumber = 2;
+  inline ::google::protobuf::uint32 epoch() const;
+  inline void set_epoch(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.ProcessId)
+ private:
+  inline void set_has_label();
+  inline void clear_has_label();
+  inline void set_has_epoch();
+  inline void clear_has_epoch();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 label_;
+  ::google::protobuf::uint32 epoch_;
+  friend void TC_SHARED_API protobuf_AddDesc_rpc_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_rpc_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_rpc_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ProcessId* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ObjectAddress : public ::google::protobuf::Message {
+ public:
+  ObjectAddress();
+  virtual ~ObjectAddress();
+
+  ObjectAddress(const ObjectAddress& from);
+
+  inline ObjectAddress& operator=(const ObjectAddress& 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 ObjectAddress& default_instance();
+
+  void Swap(ObjectAddress* other);
+
+  // implements Message ----------------------------------------------
+
+  ObjectAddress* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ObjectAddress& from);
+  void MergeFrom(const ObjectAddress& 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.ProcessId host = 1;
+  inline bool has_host() const;
+  inline void clear_host();
+  static const int kHostFieldNumber = 1;
+  inline const ::bgs::protocol::ProcessId& host() const;
+  inline ::bgs::protocol::ProcessId* mutable_host();
+  inline ::bgs::protocol::ProcessId* release_host();
+  inline void set_allocated_host(::bgs::protocol::ProcessId* host);
+
+  // optional uint64 object_id = 2 [default = 0];
+  inline bool has_object_id() const;
+  inline void clear_object_id();
+  static const int kObjectIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 object_id() const;
+  inline void set_object_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.ObjectAddress)
+ private:
+  inline void set_has_host();
+  inline void clear_has_host();
+  inline void set_has_object_id();
+  inline void clear_has_object_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::ProcessId* host_;
+  ::google::protobuf::uint64 object_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_rpc_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_rpc_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_rpc_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ObjectAddress* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API NoData : public ::google::protobuf::Message {
+ public:
+  NoData();
+  virtual ~NoData();
+
+  NoData(const NoData& from);
+
+  inline NoData& operator=(const NoData& 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 NoData& default_instance();
+
+  void Swap(NoData* other);
+
+  // implements Message ----------------------------------------------
+
+  NoData* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const NoData& from);
+  void MergeFrom(const NoData& 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 -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.NoData)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  friend void TC_SHARED_API protobuf_AddDesc_rpc_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_rpc_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_rpc_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static NoData* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ErrorInfo : public ::google::protobuf::Message {
+ public:
+  ErrorInfo();
+  virtual ~ErrorInfo();
+
+  ErrorInfo(const ErrorInfo& from);
+
+  inline ErrorInfo& operator=(const ErrorInfo& 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 ErrorInfo& default_instance();
+
+  void Swap(ErrorInfo* other);
+
+  // implements Message ----------------------------------------------
+
+  ErrorInfo* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ErrorInfo& from);
+  void MergeFrom(const ErrorInfo& 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.ObjectAddress object_address = 1;
+  inline bool has_object_address() const;
+  inline void clear_object_address();
+  static const int kObjectAddressFieldNumber = 1;
+  inline const ::bgs::protocol::ObjectAddress& object_address() const;
+  inline ::bgs::protocol::ObjectAddress* mutable_object_address();
+  inline ::bgs::protocol::ObjectAddress* release_object_address();
+  inline void set_allocated_object_address(::bgs::protocol::ObjectAddress* object_address);
+
+  // required uint32 status = 2;
+  inline bool has_status() const;
+  inline void clear_status();
+  static const int kStatusFieldNumber = 2;
+  inline ::google::protobuf::uint32 status() const;
+  inline void set_status(::google::protobuf::uint32 value);
+
+  // required uint32 service_hash = 3;
+  inline bool has_service_hash() const;
+  inline void clear_service_hash();
+  static const int kServiceHashFieldNumber = 3;
+  inline ::google::protobuf::uint32 service_hash() const;
+  inline void set_service_hash(::google::protobuf::uint32 value);
+
+  // required uint32 method_id = 4;
+  inline bool has_method_id() const;
+  inline void clear_method_id();
+  static const int kMethodIdFieldNumber = 4;
+  inline ::google::protobuf::uint32 method_id() const;
+  inline void set_method_id(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.ErrorInfo)
+ private:
+  inline void set_has_object_address();
+  inline void clear_has_object_address();
+  inline void set_has_status();
+  inline void clear_has_status();
+  inline void set_has_service_hash();
+  inline void clear_has_service_hash();
+  inline void set_has_method_id();
+  inline void clear_has_method_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::ObjectAddress* object_address_;
+  ::google::protobuf::uint32 status_;
+  ::google::protobuf::uint32 service_hash_;
+  ::google::protobuf::uint32 method_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_rpc_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_rpc_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_rpc_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static ErrorInfo* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API Header : public ::google::protobuf::Message {
+ public:
+  Header();
+  virtual ~Header();
+
+  Header(const Header& from);
+
+  inline Header& operator=(const Header& 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 Header& default_instance();
+
+  void Swap(Header* other);
+
+  // implements Message ----------------------------------------------
+
+  Header* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const Header& from);
+  void MergeFrom(const Header& 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 service_id = 1;
+  inline bool has_service_id() const;
+  inline void clear_service_id();
+  static const int kServiceIdFieldNumber = 1;
+  inline ::google::protobuf::uint32 service_id() const;
+  inline void set_service_id(::google::protobuf::uint32 value);
+
+  // optional uint32 method_id = 2;
+  inline bool has_method_id() const;
+  inline void clear_method_id();
+  static const int kMethodIdFieldNumber = 2;
+  inline ::google::protobuf::uint32 method_id() const;
+  inline void set_method_id(::google::protobuf::uint32 value);
+
+  // required uint32 token = 3;
+  inline bool has_token() const;
+  inline void clear_token();
+  static const int kTokenFieldNumber = 3;
+  inline ::google::protobuf::uint32 token() const;
+  inline void set_token(::google::protobuf::uint32 value);
+
+  // optional uint64 object_id = 4 [default = 0];
+  inline bool has_object_id() const;
+  inline void clear_object_id();
+  static const int kObjectIdFieldNumber = 4;
+  inline ::google::protobuf::uint64 object_id() const;
+  inline void set_object_id(::google::protobuf::uint64 value);
+
+  // optional uint32 size = 5 [default = 0];
+  inline bool has_size() const;
+  inline void clear_size();
+  static const int kSizeFieldNumber = 5;
+  inline ::google::protobuf::uint32 size() const;
+  inline void set_size(::google::protobuf::uint32 value);
+
+  // optional uint32 status = 6 [default = 0];
+  inline bool has_status() const;
+  inline void clear_status();
+  static const int kStatusFieldNumber = 6;
+  inline ::google::protobuf::uint32 status() const;
+  inline void set_status(::google::protobuf::uint32 value);
+
+  // repeated .bgs.protocol.ErrorInfo error = 7;
+  inline int error_size() const;
+  inline void clear_error();
+  static const int kErrorFieldNumber = 7;
+  inline const ::bgs::protocol::ErrorInfo& error(int index) const;
+  inline ::bgs::protocol::ErrorInfo* mutable_error(int index);
+  inline ::bgs::protocol::ErrorInfo* add_error();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ErrorInfo >&
+      error() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ErrorInfo >*
+      mutable_error();
+
+  // optional uint64 timeout = 8;
+  inline bool has_timeout() const;
+  inline void clear_timeout();
+  static const int kTimeoutFieldNumber = 8;
+  inline ::google::protobuf::uint64 timeout() const;
+  inline void set_timeout(::google::protobuf::uint64 value);
+
+  // optional bool is_response = 9;
+  inline bool has_is_response() const;
+  inline void clear_is_response();
+  static const int kIsResponseFieldNumber = 9;
+  inline bool is_response() const;
+  inline void set_is_response(bool value);
+
+  // repeated .bgs.protocol.ProcessId forward_targets = 10;
+  inline int forward_targets_size() const;
+  inline void clear_forward_targets();
+  static const int kForwardTargetsFieldNumber = 10;
+  inline const ::bgs::protocol::ProcessId& forward_targets(int index) const;
+  inline ::bgs::protocol::ProcessId* mutable_forward_targets(int index);
+  inline ::bgs::protocol::ProcessId* add_forward_targets();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ProcessId >&
+      forward_targets() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ProcessId >*
+      mutable_forward_targets();
+
+  // optional fixed32 service_hash = 11;
+  inline bool has_service_hash() const;
+  inline void clear_service_hash();
+  static const int kServiceHashFieldNumber = 11;
+  inline ::google::protobuf::uint32 service_hash() const;
+  inline void set_service_hash(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.Header)
+ private:
+  inline void set_has_service_id();
+  inline void clear_has_service_id();
+  inline void set_has_method_id();
+  inline void clear_has_method_id();
+  inline void set_has_token();
+  inline void clear_has_token();
+  inline void set_has_object_id();
+  inline void clear_has_object_id();
+  inline void set_has_size();
+  inline void clear_has_size();
+  inline void set_has_status();
+  inline void clear_has_status();
+  inline void set_has_timeout();
+  inline void clear_has_timeout();
+  inline void set_has_is_response();
+  inline void clear_has_is_response();
+  inline void set_has_service_hash();
+  inline void clear_has_service_hash();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 service_id_;
+  ::google::protobuf::uint32 method_id_;
+  ::google::protobuf::uint64 object_id_;
+  ::google::protobuf::uint32 token_;
+  ::google::protobuf::uint32 size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ErrorInfo > error_;
+  ::google::protobuf::uint32 status_;
+  bool is_response_;
+  ::google::protobuf::uint64 timeout_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ProcessId > forward_targets_;
+  ::google::protobuf::uint32 service_hash_;
+  friend void TC_SHARED_API protobuf_AddDesc_rpc_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_rpc_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_rpc_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static Header* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// NO_RESPONSE
+
+// -------------------------------------------------------------------
+
+// Address
+
+// required string address = 1;
+inline bool Address::has_address() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Address::set_has_address() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Address::clear_has_address() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Address::clear_address() {
+  if (address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    address_->clear();
+  }
+  clear_has_address();
+}
+inline const ::std::string& Address::address() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Address.address)
+  return *address_;
+}
+inline void Address::set_address(const ::std::string& value) {
+  set_has_address();
+  if (address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    address_ = new ::std::string;
+  }
+  address_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.Address.address)
+}
+inline void Address::set_address(const char* value) {
+  set_has_address();
+  if (address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    address_ = new ::std::string;
+  }
+  address_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.Address.address)
+}
+inline void Address::set_address(const char* value, size_t size) {
+  set_has_address();
+  if (address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    address_ = new ::std::string;
+  }
+  address_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.Address.address)
+}
+inline ::std::string* Address::mutable_address() {
+  set_has_address();
+  if (address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    address_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Address.address)
+  return address_;
+}
+inline ::std::string* Address::release_address() {
+  clear_has_address();
+  if (address_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = address_;
+    address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void Address::set_allocated_address(::std::string* address) {
+  if (address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete address_;
+  }
+  if (address) {
+    set_has_address();
+    address_ = address;
+  } else {
+    clear_has_address();
+    address_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.Address.address)
+}
+
+// optional uint32 port = 2;
+inline bool Address::has_port() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Address::set_has_port() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Address::clear_has_port() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Address::clear_port() {
+  port_ = 0u;
+  clear_has_port();
+}
+inline ::google::protobuf::uint32 Address::port() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Address.port)
+  return port_;
+}
+inline void Address::set_port(::google::protobuf::uint32 value) {
+  set_has_port();
+  port_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Address.port)
+}
+
+// -------------------------------------------------------------------
+
+// ProcessId
+
+// required uint32 label = 1;
+inline bool ProcessId::has_label() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ProcessId::set_has_label() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ProcessId::clear_has_label() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ProcessId::clear_label() {
+  label_ = 0u;
+  clear_has_label();
+}
+inline ::google::protobuf::uint32 ProcessId::label() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.ProcessId.label)
+  return label_;
+}
+inline void ProcessId::set_label(::google::protobuf::uint32 value) {
+  set_has_label();
+  label_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.ProcessId.label)
+}
+
+// required uint32 epoch = 2;
+inline bool ProcessId::has_epoch() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ProcessId::set_has_epoch() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ProcessId::clear_has_epoch() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ProcessId::clear_epoch() {
+  epoch_ = 0u;
+  clear_has_epoch();
+}
+inline ::google::protobuf::uint32 ProcessId::epoch() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.ProcessId.epoch)
+  return epoch_;
+}
+inline void ProcessId::set_epoch(::google::protobuf::uint32 value) {
+  set_has_epoch();
+  epoch_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.ProcessId.epoch)
+}
+
+// -------------------------------------------------------------------
+
+// ObjectAddress
+
+// required .bgs.protocol.ProcessId host = 1;
+inline bool ObjectAddress::has_host() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ObjectAddress::set_has_host() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ObjectAddress::clear_has_host() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ObjectAddress::clear_host() {
+  if (host_ != NULL) host_->::bgs::protocol::ProcessId::Clear();
+  clear_has_host();
+}
+inline const ::bgs::protocol::ProcessId& ObjectAddress::host() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.ObjectAddress.host)
+  return host_ != NULL ? *host_ : *default_instance_->host_;
+}
+inline ::bgs::protocol::ProcessId* ObjectAddress::mutable_host() {
+  set_has_host();
+  if (host_ == NULL) host_ = new ::bgs::protocol::ProcessId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.ObjectAddress.host)
+  return host_;
+}
+inline ::bgs::protocol::ProcessId* ObjectAddress::release_host() {
+  clear_has_host();
+  ::bgs::protocol::ProcessId* temp = host_;
+  host_ = NULL;
+  return temp;
+}
+inline void ObjectAddress::set_allocated_host(::bgs::protocol::ProcessId* host) {
+  delete host_;
+  host_ = host;
+  if (host) {
+    set_has_host();
+  } else {
+    clear_has_host();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.ObjectAddress.host)
+}
+
+// optional uint64 object_id = 2 [default = 0];
+inline bool ObjectAddress::has_object_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ObjectAddress::set_has_object_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ObjectAddress::clear_has_object_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ObjectAddress::clear_object_id() {
+  object_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_object_id();
+}
+inline ::google::protobuf::uint64 ObjectAddress::object_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.ObjectAddress.object_id)
+  return object_id_;
+}
+inline void ObjectAddress::set_object_id(::google::protobuf::uint64 value) {
+  set_has_object_id();
+  object_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.ObjectAddress.object_id)
+}
+
+// -------------------------------------------------------------------
+
+// NoData
+
+// -------------------------------------------------------------------
+
+// ErrorInfo
+
+// required .bgs.protocol.ObjectAddress object_address = 1;
+inline bool ErrorInfo::has_object_address() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ErrorInfo::set_has_object_address() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ErrorInfo::clear_has_object_address() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ErrorInfo::clear_object_address() {
+  if (object_address_ != NULL) object_address_->::bgs::protocol::ObjectAddress::Clear();
+  clear_has_object_address();
+}
+inline const ::bgs::protocol::ObjectAddress& ErrorInfo::object_address() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.ErrorInfo.object_address)
+  return object_address_ != NULL ? *object_address_ : *default_instance_->object_address_;
+}
+inline ::bgs::protocol::ObjectAddress* ErrorInfo::mutable_object_address() {
+  set_has_object_address();
+  if (object_address_ == NULL) object_address_ = new ::bgs::protocol::ObjectAddress;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.ErrorInfo.object_address)
+  return object_address_;
+}
+inline ::bgs::protocol::ObjectAddress* ErrorInfo::release_object_address() {
+  clear_has_object_address();
+  ::bgs::protocol::ObjectAddress* temp = object_address_;
+  object_address_ = NULL;
+  return temp;
+}
+inline void ErrorInfo::set_allocated_object_address(::bgs::protocol::ObjectAddress* object_address) {
+  delete object_address_;
+  object_address_ = object_address;
+  if (object_address) {
+    set_has_object_address();
+  } else {
+    clear_has_object_address();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.ErrorInfo.object_address)
+}
+
+// required uint32 status = 2;
+inline bool ErrorInfo::has_status() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ErrorInfo::set_has_status() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ErrorInfo::clear_has_status() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ErrorInfo::clear_status() {
+  status_ = 0u;
+  clear_has_status();
+}
+inline ::google::protobuf::uint32 ErrorInfo::status() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.ErrorInfo.status)
+  return status_;
+}
+inline void ErrorInfo::set_status(::google::protobuf::uint32 value) {
+  set_has_status();
+  status_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.ErrorInfo.status)
+}
+
+// required uint32 service_hash = 3;
+inline bool ErrorInfo::has_service_hash() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ErrorInfo::set_has_service_hash() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ErrorInfo::clear_has_service_hash() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ErrorInfo::clear_service_hash() {
+  service_hash_ = 0u;
+  clear_has_service_hash();
+}
+inline ::google::protobuf::uint32 ErrorInfo::service_hash() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.ErrorInfo.service_hash)
+  return service_hash_;
+}
+inline void ErrorInfo::set_service_hash(::google::protobuf::uint32 value) {
+  set_has_service_hash();
+  service_hash_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.ErrorInfo.service_hash)
+}
+
+// required uint32 method_id = 4;
+inline bool ErrorInfo::has_method_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void ErrorInfo::set_has_method_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void ErrorInfo::clear_has_method_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void ErrorInfo::clear_method_id() {
+  method_id_ = 0u;
+  clear_has_method_id();
+}
+inline ::google::protobuf::uint32 ErrorInfo::method_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.ErrorInfo.method_id)
+  return method_id_;
+}
+inline void ErrorInfo::set_method_id(::google::protobuf::uint32 value) {
+  set_has_method_id();
+  method_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.ErrorInfo.method_id)
+}
+
+// -------------------------------------------------------------------
+
+// Header
+
+// required uint32 service_id = 1;
+inline bool Header::has_service_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Header::set_has_service_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Header::clear_has_service_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Header::clear_service_id() {
+  service_id_ = 0u;
+  clear_has_service_id();
+}
+inline ::google::protobuf::uint32 Header::service_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Header.service_id)
+  return service_id_;
+}
+inline void Header::set_service_id(::google::protobuf::uint32 value) {
+  set_has_service_id();
+  service_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Header.service_id)
+}
+
+// optional uint32 method_id = 2;
+inline bool Header::has_method_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Header::set_has_method_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Header::clear_has_method_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Header::clear_method_id() {
+  method_id_ = 0u;
+  clear_has_method_id();
+}
+inline ::google::protobuf::uint32 Header::method_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Header.method_id)
+  return method_id_;
+}
+inline void Header::set_method_id(::google::protobuf::uint32 value) {
+  set_has_method_id();
+  method_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Header.method_id)
+}
+
+// required uint32 token = 3;
+inline bool Header::has_token() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Header::set_has_token() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Header::clear_has_token() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Header::clear_token() {
+  token_ = 0u;
+  clear_has_token();
+}
+inline ::google::protobuf::uint32 Header::token() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Header.token)
+  return token_;
+}
+inline void Header::set_token(::google::protobuf::uint32 value) {
+  set_has_token();
+  token_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Header.token)
+}
+
+// optional uint64 object_id = 4 [default = 0];
+inline bool Header::has_object_id() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Header::set_has_object_id() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Header::clear_has_object_id() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Header::clear_object_id() {
+  object_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_object_id();
+}
+inline ::google::protobuf::uint64 Header::object_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Header.object_id)
+  return object_id_;
+}
+inline void Header::set_object_id(::google::protobuf::uint64 value) {
+  set_has_object_id();
+  object_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Header.object_id)
+}
+
+// optional uint32 size = 5 [default = 0];
+inline bool Header::has_size() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void Header::set_has_size() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void Header::clear_has_size() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void Header::clear_size() {
+  size_ = 0u;
+  clear_has_size();
+}
+inline ::google::protobuf::uint32 Header::size() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Header.size)
+  return size_;
+}
+inline void Header::set_size(::google::protobuf::uint32 value) {
+  set_has_size();
+  size_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Header.size)
+}
+
+// optional uint32 status = 6 [default = 0];
+inline bool Header::has_status() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void Header::set_has_status() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void Header::clear_has_status() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void Header::clear_status() {
+  status_ = 0u;
+  clear_has_status();
+}
+inline ::google::protobuf::uint32 Header::status() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Header.status)
+  return status_;
+}
+inline void Header::set_status(::google::protobuf::uint32 value) {
+  set_has_status();
+  status_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Header.status)
+}
+
+// repeated .bgs.protocol.ErrorInfo error = 7;
+inline int Header::error_size() const {
+  return error_.size();
+}
+inline void Header::clear_error() {
+  error_.Clear();
+}
+inline const ::bgs::protocol::ErrorInfo& Header::error(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Header.error)
+  return error_.Get(index);
+}
+inline ::bgs::protocol::ErrorInfo* Header::mutable_error(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Header.error)
+  return error_.Mutable(index);
+}
+inline ::bgs::protocol::ErrorInfo* Header::add_error() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.Header.error)
+  return error_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ErrorInfo >&
+Header::error() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.Header.error)
+  return error_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ErrorInfo >*
+Header::mutable_error() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.Header.error)
+  return &error_;
+}
+
+// optional uint64 timeout = 8;
+inline bool Header::has_timeout() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void Header::set_has_timeout() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void Header::clear_has_timeout() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void Header::clear_timeout() {
+  timeout_ = GOOGLE_ULONGLONG(0);
+  clear_has_timeout();
+}
+inline ::google::protobuf::uint64 Header::timeout() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Header.timeout)
+  return timeout_;
+}
+inline void Header::set_timeout(::google::protobuf::uint64 value) {
+  set_has_timeout();
+  timeout_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Header.timeout)
+}
+
+// optional bool is_response = 9;
+inline bool Header::has_is_response() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void Header::set_has_is_response() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void Header::clear_has_is_response() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void Header::clear_is_response() {
+  is_response_ = false;
+  clear_has_is_response();
+}
+inline bool Header::is_response() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Header.is_response)
+  return is_response_;
+}
+inline void Header::set_is_response(bool value) {
+  set_has_is_response();
+  is_response_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Header.is_response)
+}
+
+// repeated .bgs.protocol.ProcessId forward_targets = 10;
+inline int Header::forward_targets_size() const {
+  return forward_targets_.size();
+}
+inline void Header::clear_forward_targets() {
+  forward_targets_.Clear();
+}
+inline const ::bgs::protocol::ProcessId& Header::forward_targets(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Header.forward_targets)
+  return forward_targets_.Get(index);
+}
+inline ::bgs::protocol::ProcessId* Header::mutable_forward_targets(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.Header.forward_targets)
+  return forward_targets_.Mutable(index);
+}
+inline ::bgs::protocol::ProcessId* Header::add_forward_targets() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.Header.forward_targets)
+  return forward_targets_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ProcessId >&
+Header::forward_targets() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.Header.forward_targets)
+  return forward_targets_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::ProcessId >*
+Header::mutable_forward_targets() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.Header.forward_targets)
+  return &forward_targets_;
+}
+
+// optional fixed32 service_hash = 11;
+inline bool Header::has_service_hash() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void Header::set_has_service_hash() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void Header::clear_has_service_hash() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void Header::clear_service_hash() {
+  service_hash_ = 0u;
+  clear_has_service_hash();
+}
+inline ::google::protobuf::uint32 Header::service_hash() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.Header.service_hash)
+  return service_hash_;
+}
+inline void Header::set_service_hash(::google::protobuf::uint32 value) {
+  set_has_service_hash();
+  service_hash_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.Header.service_hash)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_rpc_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/Client/user_manager_service.pb.cc b/src/server/proto/Client/user_manager_service.pb.cc
new file mode 100644
index 00000000000..ba4d0c63190
--- /dev/null
+++ b/src/server/proto/Client/user_manager_service.pb.cc
@@ -0,0 +1,4520 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: user_manager_service.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "user_manager_service.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+#include "BattlenetRpcErrorCodes.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace user_manager {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* SubscribeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscribeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* SubscribeResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  SubscribeResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UnsubscribeRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UnsubscribeRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AddRecentPlayersRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AddRecentPlayersRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* AddRecentPlayersResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  AddRecentPlayersResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClearRecentPlayersRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClearRecentPlayersRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* ClearRecentPlayersResponse_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  ClearRecentPlayersResponse_reflection_ = NULL;
+const ::google::protobuf::Descriptor* BlockPlayerRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  BlockPlayerRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* UnblockPlayerRequest_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  UnblockPlayerRequest_reflection_ = NULL;
+const ::google::protobuf::Descriptor* BlockedPlayerAddedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  BlockedPlayerAddedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* BlockedPlayerRemovedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  BlockedPlayerRemovedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RecentPlayersAddedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RecentPlayersAddedNotification_reflection_ = NULL;
+const ::google::protobuf::Descriptor* RecentPlayersRemovedNotification_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RecentPlayersRemovedNotification_reflection_ = NULL;
+const ::google::protobuf::ServiceDescriptor* UserManagerService_descriptor_ = NULL;
+const ::google::protobuf::ServiceDescriptor* UserManagerListener_descriptor_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto() {
+  protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "user_manager_service.proto");
+  GOOGLE_CHECK(file != NULL);
+  SubscribeRequest_descriptor_ = file->message_type(0);
+  static const int SubscribeRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, object_id_),
+  };
+  SubscribeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscribeRequest_descriptor_,
+      SubscribeRequest::default_instance_,
+      SubscribeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscribeRequest));
+  SubscribeResponse_descriptor_ = file->message_type(1);
+  static const int SubscribeResponse_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, blocked_players_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, recent_players_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, role_),
+  };
+  SubscribeResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      SubscribeResponse_descriptor_,
+      SubscribeResponse::default_instance_,
+      SubscribeResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SubscribeResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(SubscribeResponse));
+  UnsubscribeRequest_descriptor_ = file->message_type(2);
+  static const int UnsubscribeRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, object_id_),
+  };
+  UnsubscribeRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UnsubscribeRequest_descriptor_,
+      UnsubscribeRequest::default_instance_,
+      UnsubscribeRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnsubscribeRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UnsubscribeRequest));
+  AddRecentPlayersRequest_descriptor_ = file->message_type(3);
+  static const int AddRecentPlayersRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersRequest, players_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersRequest, program_),
+  };
+  AddRecentPlayersRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AddRecentPlayersRequest_descriptor_,
+      AddRecentPlayersRequest::default_instance_,
+      AddRecentPlayersRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AddRecentPlayersRequest));
+  AddRecentPlayersResponse_descriptor_ = file->message_type(4);
+  static const int AddRecentPlayersResponse_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersResponse, players_added_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersResponse, players_removed_),
+  };
+  AddRecentPlayersResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      AddRecentPlayersResponse_descriptor_,
+      AddRecentPlayersResponse::default_instance_,
+      AddRecentPlayersResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AddRecentPlayersResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(AddRecentPlayersResponse));
+  ClearRecentPlayersRequest_descriptor_ = file->message_type(5);
+  static const int ClearRecentPlayersRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersRequest, program_),
+  };
+  ClearRecentPlayersRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClearRecentPlayersRequest_descriptor_,
+      ClearRecentPlayersRequest::default_instance_,
+      ClearRecentPlayersRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClearRecentPlayersRequest));
+  ClearRecentPlayersResponse_descriptor_ = file->message_type(6);
+  static const int ClearRecentPlayersResponse_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersResponse, players_removed_),
+  };
+  ClearRecentPlayersResponse_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      ClearRecentPlayersResponse_descriptor_,
+      ClearRecentPlayersResponse::default_instance_,
+      ClearRecentPlayersResponse_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersResponse, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClearRecentPlayersResponse, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(ClearRecentPlayersResponse));
+  BlockPlayerRequest_descriptor_ = file->message_type(7);
+  static const int BlockPlayerRequest_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockPlayerRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockPlayerRequest, target_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockPlayerRequest, role_),
+  };
+  BlockPlayerRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      BlockPlayerRequest_descriptor_,
+      BlockPlayerRequest::default_instance_,
+      BlockPlayerRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockPlayerRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockPlayerRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(BlockPlayerRequest));
+  UnblockPlayerRequest_descriptor_ = file->message_type(8);
+  static const int UnblockPlayerRequest_offsets_[2] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnblockPlayerRequest, agent_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnblockPlayerRequest, target_id_),
+  };
+  UnblockPlayerRequest_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      UnblockPlayerRequest_descriptor_,
+      UnblockPlayerRequest::default_instance_,
+      UnblockPlayerRequest_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnblockPlayerRequest, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UnblockPlayerRequest, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(UnblockPlayerRequest));
+  BlockedPlayerAddedNotification_descriptor_ = file->message_type(9);
+  static const int BlockedPlayerAddedNotification_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerAddedNotification, player_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerAddedNotification, game_account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerAddedNotification, account_id_),
+  };
+  BlockedPlayerAddedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      BlockedPlayerAddedNotification_descriptor_,
+      BlockedPlayerAddedNotification::default_instance_,
+      BlockedPlayerAddedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerAddedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerAddedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(BlockedPlayerAddedNotification));
+  BlockedPlayerRemovedNotification_descriptor_ = file->message_type(10);
+  static const int BlockedPlayerRemovedNotification_offsets_[3] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerRemovedNotification, player_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerRemovedNotification, game_account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerRemovedNotification, account_id_),
+  };
+  BlockedPlayerRemovedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      BlockedPlayerRemovedNotification_descriptor_,
+      BlockedPlayerRemovedNotification::default_instance_,
+      BlockedPlayerRemovedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerRemovedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayerRemovedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(BlockedPlayerRemovedNotification));
+  RecentPlayersAddedNotification_descriptor_ = file->message_type(11);
+  static const int RecentPlayersAddedNotification_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayersAddedNotification, player_),
+  };
+  RecentPlayersAddedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RecentPlayersAddedNotification_descriptor_,
+      RecentPlayersAddedNotification::default_instance_,
+      RecentPlayersAddedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayersAddedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayersAddedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RecentPlayersAddedNotification));
+  RecentPlayersRemovedNotification_descriptor_ = file->message_type(12);
+  static const int RecentPlayersRemovedNotification_offsets_[1] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayersRemovedNotification, player_),
+  };
+  RecentPlayersRemovedNotification_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RecentPlayersRemovedNotification_descriptor_,
+      RecentPlayersRemovedNotification::default_instance_,
+      RecentPlayersRemovedNotification_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayersRemovedNotification, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayersRemovedNotification, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RecentPlayersRemovedNotification));
+  UserManagerService_descriptor_ = file->service(0);
+  UserManagerListener_descriptor_ = file->service(1);
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_user_5fmanager_5fservice_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscribeRequest_descriptor_, &SubscribeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    SubscribeResponse_descriptor_, &SubscribeResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UnsubscribeRequest_descriptor_, &UnsubscribeRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AddRecentPlayersRequest_descriptor_, &AddRecentPlayersRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    AddRecentPlayersResponse_descriptor_, &AddRecentPlayersResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClearRecentPlayersRequest_descriptor_, &ClearRecentPlayersRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    ClearRecentPlayersResponse_descriptor_, &ClearRecentPlayersResponse::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    BlockPlayerRequest_descriptor_, &BlockPlayerRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    UnblockPlayerRequest_descriptor_, &UnblockPlayerRequest::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    BlockedPlayerAddedNotification_descriptor_, &BlockedPlayerAddedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    BlockedPlayerRemovedNotification_descriptor_, &BlockedPlayerRemovedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RecentPlayersAddedNotification_descriptor_, &RecentPlayersAddedNotification::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RecentPlayersRemovedNotification_descriptor_, &RecentPlayersRemovedNotification::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto() {
+  delete SubscribeRequest::default_instance_;
+  delete SubscribeRequest_reflection_;
+  delete SubscribeResponse::default_instance_;
+  delete SubscribeResponse_reflection_;
+  delete UnsubscribeRequest::default_instance_;
+  delete UnsubscribeRequest_reflection_;
+  delete AddRecentPlayersRequest::default_instance_;
+  delete AddRecentPlayersRequest_reflection_;
+  delete AddRecentPlayersResponse::default_instance_;
+  delete AddRecentPlayersResponse_reflection_;
+  delete ClearRecentPlayersRequest::default_instance_;
+  delete ClearRecentPlayersRequest_reflection_;
+  delete ClearRecentPlayersResponse::default_instance_;
+  delete ClearRecentPlayersResponse_reflection_;
+  delete BlockPlayerRequest::default_instance_;
+  delete BlockPlayerRequest_reflection_;
+  delete UnblockPlayerRequest::default_instance_;
+  delete UnblockPlayerRequest_reflection_;
+  delete BlockedPlayerAddedNotification::default_instance_;
+  delete BlockedPlayerAddedNotification_reflection_;
+  delete BlockedPlayerRemovedNotification::default_instance_;
+  delete BlockedPlayerRemovedNotification_reflection_;
+  delete RecentPlayersAddedNotification::default_instance_;
+  delete RecentPlayersAddedNotification_reflection_;
+  delete RecentPlayersRemovedNotification::default_instance_;
+  delete RecentPlayersRemovedNotification_reflection_;
+}
+
+void protobuf_AddDesc_user_5fmanager_5fservice_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::user_manager::v1::protobuf_AddDesc_user_5fmanager_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_role_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_rpc_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\032user_manager_service.proto\022\034bgs.protoc"
+    "ol.user_manager.v1\032\030user_manager_types.p"
+    "roto\032\022entity_types.proto\032\020role_types.pro"
+    "to\032\017rpc_types.proto\"O\n\020SubscribeRequest\022"
+    "(\n\010agent_id\030\001 \001(\0132\026.bgs.protocol.EntityI"
+    "d\022\021\n\tobject_id\030\002 \002(\004\"\277\001\n\021SubscribeRespon"
+    "se\022D\n\017blocked_players\030\001 \003(\0132+.bgs.protoc"
+    "ol.user_manager.v1.BlockedPlayer\022B\n\016rece"
+    "nt_players\030\002 \003(\0132*.bgs.protocol.user_man"
+    "ager.v1.RecentPlayer\022 \n\004role\030\003 \003(\0132\022.bgs"
+    ".protocol.Role\"Q\n\022UnsubscribeRequest\022(\n\010"
+    "agent_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022\021"
+    "\n\tobject_id\030\002 \001(\004\"\221\001\n\027AddRecentPlayersRe"
+    "quest\022;\n\007players\030\001 \003(\0132*.bgs.protocol.us"
+    "er_manager.v1.RecentPlayer\022(\n\010agent_id\030\002"
+    " \001(\0132\026.bgs.protocol.EntityId\022\017\n\007program\030"
+    "\003 \001(\r\"v\n\030AddRecentPlayersResponse\022A\n\rpla"
+    "yers_added\030\001 \003(\0132*.bgs.protocol.user_man"
+    "ager.v1.RecentPlayer\022\027\n\017players_removed\030"
+    "\003 \003(\007\"V\n\031ClearRecentPlayersRequest\022(\n\010ag"
+    "ent_id\030\001 \001(\0132\026.bgs.protocol.EntityId\022\017\n\007"
+    "program\030\002 \001(\r\"5\n\032ClearRecentPlayersRespo"
+    "nse\022\027\n\017players_removed\030\001 \003(\007\"w\n\022BlockPla"
+    "yerRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.proto"
+    "col.EntityId\022)\n\ttarget_id\030\002 \002(\0132\026.bgs.pr"
+    "otocol.EntityId\022\014\n\004role\030\003 \001(\r\"k\n\024Unblock"
+    "PlayerRequest\022(\n\010agent_id\030\001 \001(\0132\026.bgs.pr"
+    "otocol.EntityId\022)\n\ttarget_id\030\002 \002(\0132\026.bgs"
+    ".protocol.EntityId\"\272\001\n\036BlockedPlayerAdde"
+    "dNotification\022;\n\006player\030\001 \002(\0132+.bgs.prot"
+    "ocol.user_manager.v1.BlockedPlayer\022/\n\017ga"
+    "me_account_id\030\002 \001(\0132\026.bgs.protocol.Entit"
+    "yId\022*\n\naccount_id\030\003 \001(\0132\026.bgs.protocol.E"
+    "ntityId\"\274\001\n BlockedPlayerRemovedNotifica"
+    "tion\022;\n\006player\030\001 \002(\0132+.bgs.protocol.user"
+    "_manager.v1.BlockedPlayer\022/\n\017game_accoun"
+    "t_id\030\002 \001(\0132\026.bgs.protocol.EntityId\022*\n\nac"
+    "count_id\030\003 \001(\0132\026.bgs.protocol.EntityId\"\\"
+    "\n\036RecentPlayersAddedNotification\022:\n\006play"
+    "er\030\001 \003(\0132*.bgs.protocol.user_manager.v1."
+    "RecentPlayer\"^\n RecentPlayersRemovedNoti"
+    "fication\022:\n\006player\030\001 \003(\0132*.bgs.protocol."
+    "user_manager.v1.RecentPlayer2\233\007\n\022UserMan"
+    "agerService\022r\n\tSubscribe\022..bgs.protocol."
+    "user_manager.v1.SubscribeRequest\032/.bgs.p"
+    "rotocol.user_manager.v1.SubscribeRespons"
+    "e\"\004\200\265\030\001\022\207\001\n\020AddRecentPlayers\0225.bgs.proto"
+    "col.user_manager.v1.AddRecentPlayersRequ"
+    "est\0326.bgs.protocol.user_manager.v1.AddRe"
+    "centPlayersResponse\"\004\200\265\030\n\022\215\001\n\022ClearRecen"
+    "tPlayers\0227.bgs.protocol.user_manager.v1."
+    "ClearRecentPlayersRequest\0328.bgs.protocol"
+    ".user_manager.v1.ClearRecentPlayersRespo"
+    "nse\"\004\200\265\030\013\022[\n\013BlockPlayer\0220.bgs.protocol."
+    "user_manager.v1.BlockPlayerRequest\032\024.bgs"
+    ".protocol.NoData\"\004\200\265\030\024\022_\n\rUnblockPlayer\022"
+    "2.bgs.protocol.user_manager.v1.UnblockPl"
+    "ayerRequest\032\024.bgs.protocol.NoData\"\004\200\265\030\025\022"
+    "e\n\025BlockPlayerForSession\0220.bgs.protocol."
+    "user_manager.v1.BlockPlayerRequest\032\024.bgs"
+    ".protocol.NoData\"\004\200\265\030(\022C\n\rLoadBlockList\022"
+    "\026.bgs.protocol.EntityId\032\024.bgs.protocol.N"
+    "oData\"\004\200\265\0302\022[\n\013Unsubscribe\0220.bgs.protoco"
+    "l.user_manager.v1.UnsubscribeRequest\032\024.b"
+    "gs.protocol.NoData\"\004\200\265\0303\0320\312>-bnet.protoc"
+    "ol.user_manager.UserManagerService2\252\004\n\023U"
+    "serManagerListener\022u\n\024OnBlockedPlayerAdd"
+    "ed\022<.bgs.protocol.user_manager.v1.Blocke"
+    "dPlayerAddedNotification\032\031.bgs.protocol."
+    "NO_RESPONSE\"\004\200\265\030\001\022y\n\026OnBlockedPlayerRemo"
+    "ved\022>.bgs.protocol.user_manager.v1.Block"
+    "edPlayerRemovedNotification\032\031.bgs.protoc"
+    "ol.NO_RESPONSE\"\004\200\265\030\002\022u\n\024OnRecentPlayersA"
+    "dded\022<.bgs.protocol.user_manager.v1.Rece"
+    "ntPlayersAddedNotification\032\031.bgs.protoco"
+    "l.NO_RESPONSE\"\004\200\265\030\013\022y\n\026OnRecentPlayersRe"
+    "moved\022>.bgs.protocol.user_manager.v1.Rec"
+    "entPlayersRemovedNotification\032\031.bgs.prot"
+    "ocol.NO_RESPONSE\"\004\200\265\030\014\032/\312>,bnet.protocol"
+    ".user_manager.UserManagerNotifyB\005H\001\200\001\000", 3198);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "user_manager_service.proto", &protobuf_RegisterTypes);
+  SubscribeRequest::default_instance_ = new SubscribeRequest();
+  SubscribeResponse::default_instance_ = new SubscribeResponse();
+  UnsubscribeRequest::default_instance_ = new UnsubscribeRequest();
+  AddRecentPlayersRequest::default_instance_ = new AddRecentPlayersRequest();
+  AddRecentPlayersResponse::default_instance_ = new AddRecentPlayersResponse();
+  ClearRecentPlayersRequest::default_instance_ = new ClearRecentPlayersRequest();
+  ClearRecentPlayersResponse::default_instance_ = new ClearRecentPlayersResponse();
+  BlockPlayerRequest::default_instance_ = new BlockPlayerRequest();
+  UnblockPlayerRequest::default_instance_ = new UnblockPlayerRequest();
+  BlockedPlayerAddedNotification::default_instance_ = new BlockedPlayerAddedNotification();
+  BlockedPlayerRemovedNotification::default_instance_ = new BlockedPlayerRemovedNotification();
+  RecentPlayersAddedNotification::default_instance_ = new RecentPlayersAddedNotification();
+  RecentPlayersRemovedNotification::default_instance_ = new RecentPlayersRemovedNotification();
+  SubscribeRequest::default_instance_->InitAsDefaultInstance();
+  SubscribeResponse::default_instance_->InitAsDefaultInstance();
+  UnsubscribeRequest::default_instance_->InitAsDefaultInstance();
+  AddRecentPlayersRequest::default_instance_->InitAsDefaultInstance();
+  AddRecentPlayersResponse::default_instance_->InitAsDefaultInstance();
+  ClearRecentPlayersRequest::default_instance_->InitAsDefaultInstance();
+  ClearRecentPlayersResponse::default_instance_->InitAsDefaultInstance();
+  BlockPlayerRequest::default_instance_->InitAsDefaultInstance();
+  UnblockPlayerRequest::default_instance_->InitAsDefaultInstance();
+  BlockedPlayerAddedNotification::default_instance_->InitAsDefaultInstance();
+  BlockedPlayerRemovedNotification::default_instance_->InitAsDefaultInstance();
+  RecentPlayersAddedNotification::default_instance_->InitAsDefaultInstance();
+  RecentPlayersRemovedNotification::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_user_5fmanager_5fservice_2eproto {
+  StaticDescriptorInitializer_user_5fmanager_5fservice_2eproto() {
+    protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  }
+} static_descriptor_initializer_user_5fmanager_5fservice_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscribeRequest::kAgentIdFieldNumber;
+const int SubscribeRequest::kObjectIdFieldNumber;
+#endif  // !_MSC_VER
+
+SubscribeRequest::SubscribeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.SubscribeRequest)
+}
+
+void SubscribeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+SubscribeRequest::SubscribeRequest(const SubscribeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.SubscribeRequest)
+}
+
+void SubscribeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  object_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscribeRequest::~SubscribeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.SubscribeRequest)
+  SharedDtor();
+}
+
+void SubscribeRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void SubscribeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscribeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscribeRequest_descriptor_;
+}
+
+const SubscribeRequest& SubscribeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SubscribeRequest* SubscribeRequest::default_instance_ = NULL;
+
+SubscribeRequest* SubscribeRequest::New() const {
+  return new SubscribeRequest;
+}
+
+void SubscribeRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    object_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscribeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.SubscribeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_object_id;
+        break;
+      }
+
+      // required uint64 object_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_object_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &object_id_)));
+          set_has_object_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.SubscribeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.SubscribeRequest)
+  return false;
+#undef DO_
+}
+
+void SubscribeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.SubscribeRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required uint64 object_id = 2;
+  if (has_object_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->object_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.SubscribeRequest)
+}
+
+::google::protobuf::uint8* SubscribeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.SubscribeRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required uint64 object_id = 2;
+  if (has_object_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->object_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.SubscribeRequest)
+  return target;
+}
+
+int SubscribeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required uint64 object_id = 2;
+    if (has_object_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->object_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscribeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscribeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscribeRequest::MergeFrom(const SubscribeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_object_id()) {
+      set_object_id(from.object_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscribeRequest::CopyFrom(const SubscribeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscribeRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void SubscribeRequest::Swap(SubscribeRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(object_id_, other->object_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscribeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscribeRequest_descriptor_;
+  metadata.reflection = SubscribeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int SubscribeResponse::kBlockedPlayersFieldNumber;
+const int SubscribeResponse::kRecentPlayersFieldNumber;
+const int SubscribeResponse::kRoleFieldNumber;
+#endif  // !_MSC_VER
+
+SubscribeResponse::SubscribeResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.SubscribeResponse)
+}
+
+void SubscribeResponse::InitAsDefaultInstance() {
+}
+
+SubscribeResponse::SubscribeResponse(const SubscribeResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.SubscribeResponse)
+}
+
+void SubscribeResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+SubscribeResponse::~SubscribeResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.SubscribeResponse)
+  SharedDtor();
+}
+
+void SubscribeResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void SubscribeResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* SubscribeResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return SubscribeResponse_descriptor_;
+}
+
+const SubscribeResponse& SubscribeResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  return *default_instance_;
+}
+
+SubscribeResponse* SubscribeResponse::default_instance_ = NULL;
+
+SubscribeResponse* SubscribeResponse::New() const {
+  return new SubscribeResponse;
+}
+
+void SubscribeResponse::Clear() {
+  blocked_players_.Clear();
+  recent_players_.Clear();
+  role_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool SubscribeResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.SubscribeResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.user_manager.v1.BlockedPlayer blocked_players = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_blocked_players:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_blocked_players()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_blocked_players;
+        if (input->ExpectTag(18)) goto parse_recent_players;
+        break;
+      }
+
+      // repeated .bgs.protocol.user_manager.v1.RecentPlayer recent_players = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_recent_players:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_recent_players()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_recent_players;
+        if (input->ExpectTag(26)) goto parse_role;
+        break;
+      }
+
+      // repeated .bgs.protocol.Role role = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_role:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_role()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_role;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.SubscribeResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.SubscribeResponse)
+  return false;
+#undef DO_
+}
+
+void SubscribeResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.SubscribeResponse)
+  // repeated .bgs.protocol.user_manager.v1.BlockedPlayer blocked_players = 1;
+  for (int i = 0; i < this->blocked_players_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->blocked_players(i), output);
+  }
+
+  // repeated .bgs.protocol.user_manager.v1.RecentPlayer recent_players = 2;
+  for (int i = 0; i < this->recent_players_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->recent_players(i), output);
+  }
+
+  // repeated .bgs.protocol.Role role = 3;
+  for (int i = 0; i < this->role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->role(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.SubscribeResponse)
+}
+
+::google::protobuf::uint8* SubscribeResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.SubscribeResponse)
+  // repeated .bgs.protocol.user_manager.v1.BlockedPlayer blocked_players = 1;
+  for (int i = 0; i < this->blocked_players_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->blocked_players(i), target);
+  }
+
+  // repeated .bgs.protocol.user_manager.v1.RecentPlayer recent_players = 2;
+  for (int i = 0; i < this->recent_players_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->recent_players(i), target);
+  }
+
+  // repeated .bgs.protocol.Role role = 3;
+  for (int i = 0; i < this->role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->role(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.SubscribeResponse)
+  return target;
+}
+
+int SubscribeResponse::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.user_manager.v1.BlockedPlayer blocked_players = 1;
+  total_size += 1 * this->blocked_players_size();
+  for (int i = 0; i < this->blocked_players_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->blocked_players(i));
+  }
+
+  // repeated .bgs.protocol.user_manager.v1.RecentPlayer recent_players = 2;
+  total_size += 1 * this->recent_players_size();
+  for (int i = 0; i < this->recent_players_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->recent_players(i));
+  }
+
+  // repeated .bgs.protocol.Role role = 3;
+  total_size += 1 * this->role_size();
+  for (int i = 0; i < this->role_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->role(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void SubscribeResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const SubscribeResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const SubscribeResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void SubscribeResponse::MergeFrom(const SubscribeResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  blocked_players_.MergeFrom(from.blocked_players_);
+  recent_players_.MergeFrom(from.recent_players_);
+  role_.MergeFrom(from.role_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void SubscribeResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void SubscribeResponse::CopyFrom(const SubscribeResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool SubscribeResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->blocked_players())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->recent_players())) return false;
+  if (!::google::protobuf::internal::AllAreInitialized(this->role())) return false;
+  return true;
+}
+
+void SubscribeResponse::Swap(SubscribeResponse* other) {
+  if (other != this) {
+    blocked_players_.Swap(&other->blocked_players_);
+    recent_players_.Swap(&other->recent_players_);
+    role_.Swap(&other->role_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata SubscribeResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = SubscribeResponse_descriptor_;
+  metadata.reflection = SubscribeResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UnsubscribeRequest::kAgentIdFieldNumber;
+const int UnsubscribeRequest::kObjectIdFieldNumber;
+#endif  // !_MSC_VER
+
+UnsubscribeRequest::UnsubscribeRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.UnsubscribeRequest)
+}
+
+void UnsubscribeRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+UnsubscribeRequest::UnsubscribeRequest(const UnsubscribeRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.UnsubscribeRequest)
+}
+
+void UnsubscribeRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  object_id_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UnsubscribeRequest::~UnsubscribeRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.UnsubscribeRequest)
+  SharedDtor();
+}
+
+void UnsubscribeRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void UnsubscribeRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UnsubscribeRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UnsubscribeRequest_descriptor_;
+}
+
+const UnsubscribeRequest& UnsubscribeRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  return *default_instance_;
+}
+
+UnsubscribeRequest* UnsubscribeRequest::default_instance_ = NULL;
+
+UnsubscribeRequest* UnsubscribeRequest::New() const {
+  return new UnsubscribeRequest;
+}
+
+void UnsubscribeRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    object_id_ = GOOGLE_ULONGLONG(0);
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UnsubscribeRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.UnsubscribeRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_object_id;
+        break;
+      }
+
+      // optional uint64 object_id = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_object_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &object_id_)));
+          set_has_object_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.UnsubscribeRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.UnsubscribeRequest)
+  return false;
+#undef DO_
+}
+
+void UnsubscribeRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.UnsubscribeRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint64 object_id = 2;
+  if (has_object_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->object_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.UnsubscribeRequest)
+}
+
+::google::protobuf::uint8* UnsubscribeRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.UnsubscribeRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint64 object_id = 2;
+  if (has_object_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->object_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.UnsubscribeRequest)
+  return target;
+}
+
+int UnsubscribeRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint64 object_id = 2;
+    if (has_object_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->object_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UnsubscribeRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UnsubscribeRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UnsubscribeRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UnsubscribeRequest::MergeFrom(const UnsubscribeRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_object_id()) {
+      set_object_id(from.object_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UnsubscribeRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UnsubscribeRequest::CopyFrom(const UnsubscribeRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UnsubscribeRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UnsubscribeRequest::Swap(UnsubscribeRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(object_id_, other->object_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UnsubscribeRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UnsubscribeRequest_descriptor_;
+  metadata.reflection = UnsubscribeRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AddRecentPlayersRequest::kPlayersFieldNumber;
+const int AddRecentPlayersRequest::kAgentIdFieldNumber;
+const int AddRecentPlayersRequest::kProgramFieldNumber;
+#endif  // !_MSC_VER
+
+AddRecentPlayersRequest::AddRecentPlayersRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.AddRecentPlayersRequest)
+}
+
+void AddRecentPlayersRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+AddRecentPlayersRequest::AddRecentPlayersRequest(const AddRecentPlayersRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.AddRecentPlayersRequest)
+}
+
+void AddRecentPlayersRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  program_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AddRecentPlayersRequest::~AddRecentPlayersRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.AddRecentPlayersRequest)
+  SharedDtor();
+}
+
+void AddRecentPlayersRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void AddRecentPlayersRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AddRecentPlayersRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AddRecentPlayersRequest_descriptor_;
+}
+
+const AddRecentPlayersRequest& AddRecentPlayersRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  return *default_instance_;
+}
+
+AddRecentPlayersRequest* AddRecentPlayersRequest::default_instance_ = NULL;
+
+AddRecentPlayersRequest* AddRecentPlayersRequest::New() const {
+  return new AddRecentPlayersRequest;
+}
+
+void AddRecentPlayersRequest::Clear() {
+  if (_has_bits_[0 / 32] & 6) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    program_ = 0u;
+  }
+  players_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AddRecentPlayersRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.AddRecentPlayersRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.user_manager.v1.RecentPlayer players = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_players:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_players()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_players;
+        if (input->ExpectTag(18)) goto parse_agent_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId agent_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_agent_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_program;
+        break;
+      }
+
+      // optional uint32 program = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.AddRecentPlayersRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.AddRecentPlayersRequest)
+  return false;
+#undef DO_
+}
+
+void AddRecentPlayersRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.AddRecentPlayersRequest)
+  // repeated .bgs.protocol.user_manager.v1.RecentPlayer players = 1;
+  for (int i = 0; i < this->players_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->players(i), output);
+  }
+
+  // optional .bgs.protocol.EntityId agent_id = 2;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->agent_id(), output);
+  }
+
+  // optional uint32 program = 3;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->program(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.AddRecentPlayersRequest)
+}
+
+::google::protobuf::uint8* AddRecentPlayersRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.AddRecentPlayersRequest)
+  // repeated .bgs.protocol.user_manager.v1.RecentPlayer players = 1;
+  for (int i = 0; i < this->players_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->players(i), target);
+  }
+
+  // optional .bgs.protocol.EntityId agent_id = 2;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->agent_id(), target);
+  }
+
+  // optional uint32 program = 3;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->program(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.AddRecentPlayersRequest)
+  return target;
+}
+
+int AddRecentPlayersRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 2;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint32 program = 3;
+    if (has_program()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->program());
+    }
+
+  }
+  // repeated .bgs.protocol.user_manager.v1.RecentPlayer players = 1;
+  total_size += 1 * this->players_size();
+  for (int i = 0; i < this->players_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->players(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AddRecentPlayersRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AddRecentPlayersRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AddRecentPlayersRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AddRecentPlayersRequest::MergeFrom(const AddRecentPlayersRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  players_.MergeFrom(from.players_);
+  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AddRecentPlayersRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AddRecentPlayersRequest::CopyFrom(const AddRecentPlayersRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AddRecentPlayersRequest::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->players())) return false;
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void AddRecentPlayersRequest::Swap(AddRecentPlayersRequest* other) {
+  if (other != this) {
+    players_.Swap(&other->players_);
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(program_, other->program_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AddRecentPlayersRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AddRecentPlayersRequest_descriptor_;
+  metadata.reflection = AddRecentPlayersRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int AddRecentPlayersResponse::kPlayersAddedFieldNumber;
+const int AddRecentPlayersResponse::kPlayersRemovedFieldNumber;
+#endif  // !_MSC_VER
+
+AddRecentPlayersResponse::AddRecentPlayersResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
+}
+
+void AddRecentPlayersResponse::InitAsDefaultInstance() {
+}
+
+AddRecentPlayersResponse::AddRecentPlayersResponse(const AddRecentPlayersResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
+}
+
+void AddRecentPlayersResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+AddRecentPlayersResponse::~AddRecentPlayersResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
+  SharedDtor();
+}
+
+void AddRecentPlayersResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void AddRecentPlayersResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* AddRecentPlayersResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return AddRecentPlayersResponse_descriptor_;
+}
+
+const AddRecentPlayersResponse& AddRecentPlayersResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  return *default_instance_;
+}
+
+AddRecentPlayersResponse* AddRecentPlayersResponse::default_instance_ = NULL;
+
+AddRecentPlayersResponse* AddRecentPlayersResponse::New() const {
+  return new AddRecentPlayersResponse;
+}
+
+void AddRecentPlayersResponse::Clear() {
+  players_added_.Clear();
+  players_removed_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool AddRecentPlayersResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_players_added:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_players_added()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_players_added;
+        if (input->ExpectTag(29)) goto parse_players_removed;
+        break;
+      }
+
+      // repeated fixed32 players_removed = 3;
+      case 3: {
+        if (tag == 29) {
+         parse_players_removed:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 1, 29, input, this->mutable_players_removed())));
+        } else if (tag == 26) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, this->mutable_players_removed())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(29)) goto parse_players_removed;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
+  return false;
+#undef DO_
+}
+
+void AddRecentPlayersResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
+  // repeated .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1;
+  for (int i = 0; i < this->players_added_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->players_added(i), output);
+  }
+
+  // repeated fixed32 players_removed = 3;
+  for (int i = 0; i < this->players_removed_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(
+      3, this->players_removed(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
+}
+
+::google::protobuf::uint8* AddRecentPlayersResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
+  // repeated .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1;
+  for (int i = 0; i < this->players_added_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->players_added(i), target);
+  }
+
+  // repeated fixed32 players_removed = 3;
+  for (int i = 0; i < this->players_removed_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteFixed32ToArray(3, this->players_removed(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
+  return target;
+}
+
+int AddRecentPlayersResponse::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1;
+  total_size += 1 * this->players_added_size();
+  for (int i = 0; i < this->players_added_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->players_added(i));
+  }
+
+  // repeated fixed32 players_removed = 3;
+  {
+    int data_size = 0;
+    data_size = 4 * this->players_removed_size();
+    total_size += 1 * this->players_removed_size() + data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void AddRecentPlayersResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const AddRecentPlayersResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const AddRecentPlayersResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void AddRecentPlayersResponse::MergeFrom(const AddRecentPlayersResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  players_added_.MergeFrom(from.players_added_);
+  players_removed_.MergeFrom(from.players_removed_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void AddRecentPlayersResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void AddRecentPlayersResponse::CopyFrom(const AddRecentPlayersResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool AddRecentPlayersResponse::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->players_added())) return false;
+  return true;
+}
+
+void AddRecentPlayersResponse::Swap(AddRecentPlayersResponse* other) {
+  if (other != this) {
+    players_added_.Swap(&other->players_added_);
+    players_removed_.Swap(&other->players_removed_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata AddRecentPlayersResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = AddRecentPlayersResponse_descriptor_;
+  metadata.reflection = AddRecentPlayersResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClearRecentPlayersRequest::kAgentIdFieldNumber;
+const int ClearRecentPlayersRequest::kProgramFieldNumber;
+#endif  // !_MSC_VER
+
+ClearRecentPlayersRequest::ClearRecentPlayersRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest)
+}
+
+void ClearRecentPlayersRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+ClearRecentPlayersRequest::ClearRecentPlayersRequest(const ClearRecentPlayersRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest)
+}
+
+void ClearRecentPlayersRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  program_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClearRecentPlayersRequest::~ClearRecentPlayersRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest)
+  SharedDtor();
+}
+
+void ClearRecentPlayersRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+  }
+}
+
+void ClearRecentPlayersRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClearRecentPlayersRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClearRecentPlayersRequest_descriptor_;
+}
+
+const ClearRecentPlayersRequest& ClearRecentPlayersRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ClearRecentPlayersRequest* ClearRecentPlayersRequest::default_instance_ = NULL;
+
+ClearRecentPlayersRequest* ClearRecentPlayersRequest::New() const {
+  return new ClearRecentPlayersRequest;
+}
+
+void ClearRecentPlayersRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    program_ = 0u;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClearRecentPlayersRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_program;
+        break;
+      }
+
+      // optional uint32 program = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_program:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &program_)));
+          set_has_program();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest)
+  return false;
+#undef DO_
+}
+
+void ClearRecentPlayersRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // optional uint32 program = 2;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->program(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest)
+}
+
+::google::protobuf::uint8* ClearRecentPlayersRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // optional uint32 program = 2;
+  if (has_program()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->program(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest)
+  return target;
+}
+
+int ClearRecentPlayersRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // optional uint32 program = 2;
+    if (has_program()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->program());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClearRecentPlayersRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClearRecentPlayersRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClearRecentPlayersRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClearRecentPlayersRequest::MergeFrom(const ClearRecentPlayersRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClearRecentPlayersRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClearRecentPlayersRequest::CopyFrom(const ClearRecentPlayersRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClearRecentPlayersRequest::IsInitialized() const {
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void ClearRecentPlayersRequest::Swap(ClearRecentPlayersRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(program_, other->program_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClearRecentPlayersRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClearRecentPlayersRequest_descriptor_;
+  metadata.reflection = ClearRecentPlayersRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int ClearRecentPlayersResponse::kPlayersRemovedFieldNumber;
+#endif  // !_MSC_VER
+
+ClearRecentPlayersResponse::ClearRecentPlayersResponse()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
+}
+
+void ClearRecentPlayersResponse::InitAsDefaultInstance() {
+}
+
+ClearRecentPlayersResponse::ClearRecentPlayersResponse(const ClearRecentPlayersResponse& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
+}
+
+void ClearRecentPlayersResponse::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+ClearRecentPlayersResponse::~ClearRecentPlayersResponse() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
+  SharedDtor();
+}
+
+void ClearRecentPlayersResponse::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void ClearRecentPlayersResponse::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* ClearRecentPlayersResponse::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return ClearRecentPlayersResponse_descriptor_;
+}
+
+const ClearRecentPlayersResponse& ClearRecentPlayersResponse::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  return *default_instance_;
+}
+
+ClearRecentPlayersResponse* ClearRecentPlayersResponse::default_instance_ = NULL;
+
+ClearRecentPlayersResponse* ClearRecentPlayersResponse::New() const {
+  return new ClearRecentPlayersResponse;
+}
+
+void ClearRecentPlayersResponse::Clear() {
+  players_removed_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool ClearRecentPlayersResponse::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated fixed32 players_removed = 1;
+      case 1: {
+        if (tag == 13) {
+         parse_players_removed:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 1, 13, input, this->mutable_players_removed())));
+        } else if (tag == 10) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, this->mutable_players_removed())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(13)) goto parse_players_removed;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
+  return false;
+#undef DO_
+}
+
+void ClearRecentPlayersResponse::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
+  // repeated fixed32 players_removed = 1;
+  for (int i = 0; i < this->players_removed_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(
+      1, this->players_removed(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
+}
+
+::google::protobuf::uint8* ClearRecentPlayersResponse::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
+  // repeated fixed32 players_removed = 1;
+  for (int i = 0; i < this->players_removed_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteFixed32ToArray(1, this->players_removed(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
+  return target;
+}
+
+int ClearRecentPlayersResponse::ByteSize() const {
+  int total_size = 0;
+
+  // repeated fixed32 players_removed = 1;
+  {
+    int data_size = 0;
+    data_size = 4 * this->players_removed_size();
+    total_size += 1 * this->players_removed_size() + data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void ClearRecentPlayersResponse::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const ClearRecentPlayersResponse* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const ClearRecentPlayersResponse*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void ClearRecentPlayersResponse::MergeFrom(const ClearRecentPlayersResponse& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  players_removed_.MergeFrom(from.players_removed_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void ClearRecentPlayersResponse::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void ClearRecentPlayersResponse::CopyFrom(const ClearRecentPlayersResponse& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool ClearRecentPlayersResponse::IsInitialized() const {
+
+  return true;
+}
+
+void ClearRecentPlayersResponse::Swap(ClearRecentPlayersResponse* other) {
+  if (other != this) {
+    players_removed_.Swap(&other->players_removed_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata ClearRecentPlayersResponse::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = ClearRecentPlayersResponse_descriptor_;
+  metadata.reflection = ClearRecentPlayersResponse_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int BlockPlayerRequest::kAgentIdFieldNumber;
+const int BlockPlayerRequest::kTargetIdFieldNumber;
+const int BlockPlayerRequest::kRoleFieldNumber;
+#endif  // !_MSC_VER
+
+BlockPlayerRequest::BlockPlayerRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.BlockPlayerRequest)
+}
+
+void BlockPlayerRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+BlockPlayerRequest::BlockPlayerRequest(const BlockPlayerRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.BlockPlayerRequest)
+}
+
+void BlockPlayerRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  target_id_ = NULL;
+  role_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+BlockPlayerRequest::~BlockPlayerRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.BlockPlayerRequest)
+  SharedDtor();
+}
+
+void BlockPlayerRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete target_id_;
+  }
+}
+
+void BlockPlayerRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* BlockPlayerRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return BlockPlayerRequest_descriptor_;
+}
+
+const BlockPlayerRequest& BlockPlayerRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  return *default_instance_;
+}
+
+BlockPlayerRequest* BlockPlayerRequest::default_instance_ = NULL;
+
+BlockPlayerRequest* BlockPlayerRequest::New() const {
+  return new BlockPlayerRequest;
+}
+
+void BlockPlayerRequest::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+    }
+    role_ = 0u;
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool BlockPlayerRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.BlockPlayerRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_target_id;
+        break;
+      }
+
+      // required .bgs.protocol.EntityId target_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_target_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_role;
+        break;
+      }
+
+      // optional uint32 role = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &role_)));
+          set_has_role();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.BlockPlayerRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.BlockPlayerRequest)
+  return false;
+#undef DO_
+}
+
+void BlockPlayerRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.BlockPlayerRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->target_id(), output);
+  }
+
+  // optional uint32 role = 3;
+  if (has_role()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->role(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.BlockPlayerRequest)
+}
+
+::google::protobuf::uint8* BlockPlayerRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.BlockPlayerRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->target_id(), target);
+  }
+
+  // optional uint32 role = 3;
+  if (has_role()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->role(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.BlockPlayerRequest)
+  return target;
+}
+
+int BlockPlayerRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.EntityId target_id = 2;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+    // optional uint32 role = 3;
+    if (has_role()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->role());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void BlockPlayerRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const BlockPlayerRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const BlockPlayerRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void BlockPlayerRequest::MergeFrom(const BlockPlayerRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id());
+    }
+    if (from.has_role()) {
+      set_role(from.role());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void BlockPlayerRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void BlockPlayerRequest::CopyFrom(const BlockPlayerRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BlockPlayerRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void BlockPlayerRequest::Swap(BlockPlayerRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(target_id_, other->target_id_);
+    std::swap(role_, other->role_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata BlockPlayerRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = BlockPlayerRequest_descriptor_;
+  metadata.reflection = BlockPlayerRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int UnblockPlayerRequest::kAgentIdFieldNumber;
+const int UnblockPlayerRequest::kTargetIdFieldNumber;
+#endif  // !_MSC_VER
+
+UnblockPlayerRequest::UnblockPlayerRequest()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.UnblockPlayerRequest)
+}
+
+void UnblockPlayerRequest::InitAsDefaultInstance() {
+  agent_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  target_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+UnblockPlayerRequest::UnblockPlayerRequest(const UnblockPlayerRequest& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.UnblockPlayerRequest)
+}
+
+void UnblockPlayerRequest::SharedCtor() {
+  _cached_size_ = 0;
+  agent_id_ = NULL;
+  target_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+UnblockPlayerRequest::~UnblockPlayerRequest() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.UnblockPlayerRequest)
+  SharedDtor();
+}
+
+void UnblockPlayerRequest::SharedDtor() {
+  if (this != default_instance_) {
+    delete agent_id_;
+    delete target_id_;
+  }
+}
+
+void UnblockPlayerRequest::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* UnblockPlayerRequest::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UnblockPlayerRequest_descriptor_;
+}
+
+const UnblockPlayerRequest& UnblockPlayerRequest::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  return *default_instance_;
+}
+
+UnblockPlayerRequest* UnblockPlayerRequest::default_instance_ = NULL;
+
+UnblockPlayerRequest* UnblockPlayerRequest::New() const {
+  return new UnblockPlayerRequest;
+}
+
+void UnblockPlayerRequest::Clear() {
+  if (_has_bits_[0 / 32] & 3) {
+    if (has_agent_id()) {
+      if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_target_id()) {
+      if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool UnblockPlayerRequest::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.UnblockPlayerRequest)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .bgs.protocol.EntityId agent_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_agent_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_target_id;
+        break;
+      }
+
+      // required .bgs.protocol.EntityId target_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_target_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_target_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.UnblockPlayerRequest)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.UnblockPlayerRequest)
+  return false;
+#undef DO_
+}
+
+void UnblockPlayerRequest::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.UnblockPlayerRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->agent_id(), output);
+  }
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->target_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.UnblockPlayerRequest)
+}
+
+::google::protobuf::uint8* UnblockPlayerRequest::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.UnblockPlayerRequest)
+  // optional .bgs.protocol.EntityId agent_id = 1;
+  if (has_agent_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->agent_id(), target);
+  }
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  if (has_target_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->target_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.UnblockPlayerRequest)
+  return target;
+}
+
+int UnblockPlayerRequest::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional .bgs.protocol.EntityId agent_id = 1;
+    if (has_agent_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->agent_id());
+    }
+
+    // required .bgs.protocol.EntityId target_id = 2;
+    if (has_target_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->target_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void UnblockPlayerRequest::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const UnblockPlayerRequest* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const UnblockPlayerRequest*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void UnblockPlayerRequest::MergeFrom(const UnblockPlayerRequest& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_agent_id()) {
+      mutable_agent_id()->::bgs::protocol::EntityId::MergeFrom(from.agent_id());
+    }
+    if (from.has_target_id()) {
+      mutable_target_id()->::bgs::protocol::EntityId::MergeFrom(from.target_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void UnblockPlayerRequest::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void UnblockPlayerRequest::CopyFrom(const UnblockPlayerRequest& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool UnblockPlayerRequest::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000002) != 0x00000002) return false;
+
+  if (has_agent_id()) {
+    if (!this->agent_id().IsInitialized()) return false;
+  }
+  if (has_target_id()) {
+    if (!this->target_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void UnblockPlayerRequest::Swap(UnblockPlayerRequest* other) {
+  if (other != this) {
+    std::swap(agent_id_, other->agent_id_);
+    std::swap(target_id_, other->target_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata UnblockPlayerRequest::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = UnblockPlayerRequest_descriptor_;
+  metadata.reflection = UnblockPlayerRequest_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int BlockedPlayerAddedNotification::kPlayerFieldNumber;
+const int BlockedPlayerAddedNotification::kGameAccountIdFieldNumber;
+const int BlockedPlayerAddedNotification::kAccountIdFieldNumber;
+#endif  // !_MSC_VER
+
+BlockedPlayerAddedNotification::BlockedPlayerAddedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification)
+}
+
+void BlockedPlayerAddedNotification::InitAsDefaultInstance() {
+  player_ = const_cast< ::bgs::protocol::user_manager::v1::BlockedPlayer*>(&::bgs::protocol::user_manager::v1::BlockedPlayer::default_instance());
+  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+BlockedPlayerAddedNotification::BlockedPlayerAddedNotification(const BlockedPlayerAddedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification)
+}
+
+void BlockedPlayerAddedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  player_ = NULL;
+  game_account_id_ = NULL;
+  account_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+BlockedPlayerAddedNotification::~BlockedPlayerAddedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification)
+  SharedDtor();
+}
+
+void BlockedPlayerAddedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete player_;
+    delete game_account_id_;
+    delete account_id_;
+  }
+}
+
+void BlockedPlayerAddedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* BlockedPlayerAddedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return BlockedPlayerAddedNotification_descriptor_;
+}
+
+const BlockedPlayerAddedNotification& BlockedPlayerAddedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  return *default_instance_;
+}
+
+BlockedPlayerAddedNotification* BlockedPlayerAddedNotification::default_instance_ = NULL;
+
+BlockedPlayerAddedNotification* BlockedPlayerAddedNotification::New() const {
+  return new BlockedPlayerAddedNotification;
+}
+
+void BlockedPlayerAddedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_player()) {
+      if (player_ != NULL) player_->::bgs::protocol::user_manager::v1::BlockedPlayer::Clear();
+    }
+    if (has_game_account_id()) {
+      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool BlockedPlayerAddedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_player()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_game_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId game_account_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_game_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId account_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification)
+  return false;
+#undef DO_
+}
+
+void BlockedPlayerAddedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification)
+  // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1;
+  if (has_player()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->player(), output);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->game_account_id(), output);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 3;
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->account_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification)
+}
+
+::google::protobuf::uint8* BlockedPlayerAddedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification)
+  // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1;
+  if (has_player()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->player(), target);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->game_account_id(), target);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 3;
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->account_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification)
+  return target;
+}
+
+int BlockedPlayerAddedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1;
+    if (has_player()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->player());
+    }
+
+    // optional .bgs.protocol.EntityId game_account_id = 2;
+    if (has_game_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_id());
+    }
+
+    // optional .bgs.protocol.EntityId account_id = 3;
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void BlockedPlayerAddedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const BlockedPlayerAddedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const BlockedPlayerAddedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void BlockedPlayerAddedNotification::MergeFrom(const BlockedPlayerAddedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_player()) {
+      mutable_player()->::bgs::protocol::user_manager::v1::BlockedPlayer::MergeFrom(from.player());
+    }
+    if (from.has_game_account_id()) {
+      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+    }
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void BlockedPlayerAddedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void BlockedPlayerAddedNotification::CopyFrom(const BlockedPlayerAddedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BlockedPlayerAddedNotification::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_player()) {
+    if (!this->player().IsInitialized()) return false;
+  }
+  if (has_game_account_id()) {
+    if (!this->game_account_id().IsInitialized()) return false;
+  }
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void BlockedPlayerAddedNotification::Swap(BlockedPlayerAddedNotification* other) {
+  if (other != this) {
+    std::swap(player_, other->player_);
+    std::swap(game_account_id_, other->game_account_id_);
+    std::swap(account_id_, other->account_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata BlockedPlayerAddedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = BlockedPlayerAddedNotification_descriptor_;
+  metadata.reflection = BlockedPlayerAddedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int BlockedPlayerRemovedNotification::kPlayerFieldNumber;
+const int BlockedPlayerRemovedNotification::kGameAccountIdFieldNumber;
+const int BlockedPlayerRemovedNotification::kAccountIdFieldNumber;
+#endif  // !_MSC_VER
+
+BlockedPlayerRemovedNotification::BlockedPlayerRemovedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification)
+}
+
+void BlockedPlayerRemovedNotification::InitAsDefaultInstance() {
+  player_ = const_cast< ::bgs::protocol::user_manager::v1::BlockedPlayer*>(&::bgs::protocol::user_manager::v1::BlockedPlayer::default_instance());
+  game_account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+BlockedPlayerRemovedNotification::BlockedPlayerRemovedNotification(const BlockedPlayerRemovedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification)
+}
+
+void BlockedPlayerRemovedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  player_ = NULL;
+  game_account_id_ = NULL;
+  account_id_ = NULL;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+BlockedPlayerRemovedNotification::~BlockedPlayerRemovedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification)
+  SharedDtor();
+}
+
+void BlockedPlayerRemovedNotification::SharedDtor() {
+  if (this != default_instance_) {
+    delete player_;
+    delete game_account_id_;
+    delete account_id_;
+  }
+}
+
+void BlockedPlayerRemovedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* BlockedPlayerRemovedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return BlockedPlayerRemovedNotification_descriptor_;
+}
+
+const BlockedPlayerRemovedNotification& BlockedPlayerRemovedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  return *default_instance_;
+}
+
+BlockedPlayerRemovedNotification* BlockedPlayerRemovedNotification::default_instance_ = NULL;
+
+BlockedPlayerRemovedNotification* BlockedPlayerRemovedNotification::New() const {
+  return new BlockedPlayerRemovedNotification;
+}
+
+void BlockedPlayerRemovedNotification::Clear() {
+  if (_has_bits_[0 / 32] & 7) {
+    if (has_player()) {
+      if (player_ != NULL) player_->::bgs::protocol::user_manager::v1::BlockedPlayer::Clear();
+    }
+    if (has_game_account_id()) {
+      if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+    }
+  }
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool BlockedPlayerRemovedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_player()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_game_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId game_account_id = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_game_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_game_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_account_id;
+        break;
+      }
+
+      // optional .bgs.protocol.EntityId account_id = 3;
+      case 3: {
+        if (tag == 26) {
+         parse_account_id:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification)
+  return false;
+#undef DO_
+}
+
+void BlockedPlayerRemovedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification)
+  // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1;
+  if (has_player()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->player(), output);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->game_account_id(), output);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 3;
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      3, this->account_id(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification)
+}
+
+::google::protobuf::uint8* BlockedPlayerRemovedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification)
+  // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1;
+  if (has_player()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->player(), target);
+  }
+
+  // optional .bgs.protocol.EntityId game_account_id = 2;
+  if (has_game_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->game_account_id(), target);
+  }
+
+  // optional .bgs.protocol.EntityId account_id = 3;
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        3, this->account_id(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification)
+  return target;
+}
+
+int BlockedPlayerRemovedNotification::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1;
+    if (has_player()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->player());
+    }
+
+    // optional .bgs.protocol.EntityId game_account_id = 2;
+    if (has_game_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->game_account_id());
+    }
+
+    // optional .bgs.protocol.EntityId account_id = 3;
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void BlockedPlayerRemovedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const BlockedPlayerRemovedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const BlockedPlayerRemovedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void BlockedPlayerRemovedNotification::MergeFrom(const BlockedPlayerRemovedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_player()) {
+      mutable_player()->::bgs::protocol::user_manager::v1::BlockedPlayer::MergeFrom(from.player());
+    }
+    if (from.has_game_account_id()) {
+      mutable_game_account_id()->::bgs::protocol::EntityId::MergeFrom(from.game_account_id());
+    }
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void BlockedPlayerRemovedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void BlockedPlayerRemovedNotification::CopyFrom(const BlockedPlayerRemovedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BlockedPlayerRemovedNotification::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_player()) {
+    if (!this->player().IsInitialized()) return false;
+  }
+  if (has_game_account_id()) {
+    if (!this->game_account_id().IsInitialized()) return false;
+  }
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void BlockedPlayerRemovedNotification::Swap(BlockedPlayerRemovedNotification* other) {
+  if (other != this) {
+    std::swap(player_, other->player_);
+    std::swap(game_account_id_, other->game_account_id_);
+    std::swap(account_id_, other->account_id_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata BlockedPlayerRemovedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = BlockedPlayerRemovedNotification_descriptor_;
+  metadata.reflection = BlockedPlayerRemovedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RecentPlayersAddedNotification::kPlayerFieldNumber;
+#endif  // !_MSC_VER
+
+RecentPlayersAddedNotification::RecentPlayersAddedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification)
+}
+
+void RecentPlayersAddedNotification::InitAsDefaultInstance() {
+}
+
+RecentPlayersAddedNotification::RecentPlayersAddedNotification(const RecentPlayersAddedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification)
+}
+
+void RecentPlayersAddedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RecentPlayersAddedNotification::~RecentPlayersAddedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification)
+  SharedDtor();
+}
+
+void RecentPlayersAddedNotification::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void RecentPlayersAddedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RecentPlayersAddedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RecentPlayersAddedNotification_descriptor_;
+}
+
+const RecentPlayersAddedNotification& RecentPlayersAddedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  return *default_instance_;
+}
+
+RecentPlayersAddedNotification* RecentPlayersAddedNotification::default_instance_ = NULL;
+
+RecentPlayersAddedNotification* RecentPlayersAddedNotification::New() const {
+  return new RecentPlayersAddedNotification;
+}
+
+void RecentPlayersAddedNotification::Clear() {
+  player_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RecentPlayersAddedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_player:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_player()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_player;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification)
+  return false;
+#undef DO_
+}
+
+void RecentPlayersAddedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification)
+  // repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1;
+  for (int i = 0; i < this->player_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->player(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification)
+}
+
+::google::protobuf::uint8* RecentPlayersAddedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification)
+  // repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1;
+  for (int i = 0; i < this->player_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->player(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification)
+  return target;
+}
+
+int RecentPlayersAddedNotification::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1;
+  total_size += 1 * this->player_size();
+  for (int i = 0; i < this->player_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->player(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RecentPlayersAddedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RecentPlayersAddedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RecentPlayersAddedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RecentPlayersAddedNotification::MergeFrom(const RecentPlayersAddedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  player_.MergeFrom(from.player_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RecentPlayersAddedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RecentPlayersAddedNotification::CopyFrom(const RecentPlayersAddedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RecentPlayersAddedNotification::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->player())) return false;
+  return true;
+}
+
+void RecentPlayersAddedNotification::Swap(RecentPlayersAddedNotification* other) {
+  if (other != this) {
+    player_.Swap(&other->player_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RecentPlayersAddedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RecentPlayersAddedNotification_descriptor_;
+  metadata.reflection = RecentPlayersAddedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RecentPlayersRemovedNotification::kPlayerFieldNumber;
+#endif  // !_MSC_VER
+
+RecentPlayersRemovedNotification::RecentPlayersRemovedNotification()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification)
+}
+
+void RecentPlayersRemovedNotification::InitAsDefaultInstance() {
+}
+
+RecentPlayersRemovedNotification::RecentPlayersRemovedNotification(const RecentPlayersRemovedNotification& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification)
+}
+
+void RecentPlayersRemovedNotification::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RecentPlayersRemovedNotification::~RecentPlayersRemovedNotification() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification)
+  SharedDtor();
+}
+
+void RecentPlayersRemovedNotification::SharedDtor() {
+  if (this != default_instance_) {
+  }
+}
+
+void RecentPlayersRemovedNotification::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RecentPlayersRemovedNotification::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RecentPlayersRemovedNotification_descriptor_;
+}
+
+const RecentPlayersRemovedNotification& RecentPlayersRemovedNotification::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  return *default_instance_;
+}
+
+RecentPlayersRemovedNotification* RecentPlayersRemovedNotification::default_instance_ = NULL;
+
+RecentPlayersRemovedNotification* RecentPlayersRemovedNotification::New() const {
+  return new RecentPlayersRemovedNotification;
+}
+
+void RecentPlayersRemovedNotification::Clear() {
+  player_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RecentPlayersRemovedNotification::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1;
+      case 1: {
+        if (tag == 10) {
+         parse_player:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_player()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(10)) goto parse_player;
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification)
+  return false;
+#undef DO_
+}
+
+void RecentPlayersRemovedNotification::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification)
+  // repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1;
+  for (int i = 0; i < this->player_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->player(i), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification)
+}
+
+::google::protobuf::uint8* RecentPlayersRemovedNotification::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification)
+  // repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1;
+  for (int i = 0; i < this->player_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->player(i), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification)
+  return target;
+}
+
+int RecentPlayersRemovedNotification::ByteSize() const {
+  int total_size = 0;
+
+  // repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1;
+  total_size += 1 * this->player_size();
+  for (int i = 0; i < this->player_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->player(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RecentPlayersRemovedNotification::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RecentPlayersRemovedNotification* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RecentPlayersRemovedNotification*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RecentPlayersRemovedNotification::MergeFrom(const RecentPlayersRemovedNotification& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  player_.MergeFrom(from.player_);
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RecentPlayersRemovedNotification::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RecentPlayersRemovedNotification::CopyFrom(const RecentPlayersRemovedNotification& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RecentPlayersRemovedNotification::IsInitialized() const {
+
+  if (!::google::protobuf::internal::AllAreInitialized(this->player())) return false;
+  return true;
+}
+
+void RecentPlayersRemovedNotification::Swap(RecentPlayersRemovedNotification* other) {
+  if (other != this) {
+    player_.Swap(&other->player_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RecentPlayersRemovedNotification::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RecentPlayersRemovedNotification_descriptor_;
+  metadata.reflection = RecentPlayersRemovedNotification_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* UserManagerService::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UserManagerService_descriptor_;
+}
+
+void UserManagerService::Subscribe(::bgs::protocol::user_manager::v1::SubscribeRequest const* request, std::function<void(::bgs::protocol::user_manager::v1::SubscribeResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.Subscribe(bgs.protocol.user_manager.v1.SubscribeRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::user_manager::v1::SubscribeResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void UserManagerService::AddRecentPlayers(::bgs::protocol::user_manager::v1::AddRecentPlayersRequest const* request, std::function<void(::bgs::protocol::user_manager::v1::AddRecentPlayersResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.AddRecentPlayers(bgs.protocol.user_manager.v1.AddRecentPlayersRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 10, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::user_manager::v1::AddRecentPlayersResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void UserManagerService::ClearRecentPlayers(::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest const* request, std::function<void(::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.ClearRecentPlayers(bgs.protocol.user_manager.v1.ClearRecentPlayersRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 11, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void UserManagerService::BlockPlayer(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.BlockPlayer(bgs.protocol.user_manager.v1.BlockPlayerRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 20, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void UserManagerService::UnblockPlayer(::bgs::protocol::user_manager::v1::UnblockPlayerRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.UnblockPlayer(bgs.protocol.user_manager.v1.UnblockPlayerRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 21, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void UserManagerService::BlockPlayerForSession(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.BlockPlayerForSession(bgs.protocol.user_manager.v1.BlockPlayerRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 40, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void UserManagerService::LoadBlockList(::bgs::protocol::EntityId const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.LoadBlockList(bgs.protocol.EntityId{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 50, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void UserManagerService::Unsubscribe(::bgs::protocol::user_manager::v1::UnsubscribeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerService.Unsubscribe(bgs.protocol.user_manager.v1.UnsubscribeRequest{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 51, request, [callback{ std::move(responseCallback) }](MessageBuffer buffer) {
+    ::bgs::protocol::NoData response;
+    if (response.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize()))
+      callback(&response);
+  });
+}
+
+void UserManagerService::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::user_manager::v1::SubscribeRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.Subscribe server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::user_manager::v1::SubscribeResponse response;
+      uint32 status = HandleSubscribe(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.Subscribe(bgs.protocol.user_manager.v1.SubscribeRequest{ %s }) returned bgs.protocol.user_manager.v1.SubscribeResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 1, token, &response);
+      else
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    case 10: {
+      ::bgs::protocol::user_manager::v1::AddRecentPlayersRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.AddRecentPlayers server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 10, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::user_manager::v1::AddRecentPlayersResponse response;
+      uint32 status = HandleAddRecentPlayers(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.AddRecentPlayers(bgs.protocol.user_manager.v1.AddRecentPlayersRequest{ %s }) returned bgs.protocol.user_manager.v1.AddRecentPlayersResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 10, token, &response);
+      else
+        SendResponse(service_hash_, 10, token, status);
+      break;
+    }
+    case 11: {
+      ::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.ClearRecentPlayers server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 11, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse response;
+      uint32 status = HandleClearRecentPlayers(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.ClearRecentPlayers(bgs.protocol.user_manager.v1.ClearRecentPlayersRequest{ %s }) returned bgs.protocol.user_manager.v1.ClearRecentPlayersResponse{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 11, token, &response);
+      else
+        SendResponse(service_hash_, 11, token, status);
+      break;
+    }
+    case 20: {
+      ::bgs::protocol::user_manager::v1::BlockPlayerRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.BlockPlayer server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 20, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleBlockPlayer(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.BlockPlayer(bgs.protocol.user_manager.v1.BlockPlayerRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 20, token, &response);
+      else
+        SendResponse(service_hash_, 20, token, status);
+      break;
+    }
+    case 21: {
+      ::bgs::protocol::user_manager::v1::UnblockPlayerRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.UnblockPlayer server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 21, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleUnblockPlayer(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.UnblockPlayer(bgs.protocol.user_manager.v1.UnblockPlayerRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 21, token, &response);
+      else
+        SendResponse(service_hash_, 21, token, status);
+      break;
+    }
+    case 40: {
+      ::bgs::protocol::user_manager::v1::BlockPlayerRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.BlockPlayerForSession server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 40, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleBlockPlayerForSession(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.BlockPlayerForSession(bgs.protocol.user_manager.v1.BlockPlayerRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 40, token, &response);
+      else
+        SendResponse(service_hash_, 40, token, status);
+      break;
+    }
+    case 50: {
+      ::bgs::protocol::EntityId request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.LoadBlockList server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 50, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleLoadBlockList(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.LoadBlockList(bgs.protocol.EntityId{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 50, token, &response);
+      else
+        SendResponse(service_hash_, 50, token, status);
+      break;
+    }
+    case 51: {
+      ::bgs::protocol::user_manager::v1::UnsubscribeRequest request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerService.Unsubscribe server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 51, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      ::bgs::protocol::NoData response;
+      uint32 status = HandleUnsubscribe(&request, &response);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerService.Unsubscribe(bgs.protocol.user_manager.v1.UnsubscribeRequest{ %s }) returned bgs.protocol.NoData{ %s } status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), response.ShortDebugString().c_str(), status);
+      if (!status)
+        SendResponse(service_hash_, 51, token, &response);
+      else
+        SendResponse(service_hash_, 51, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 UserManagerService::HandleSubscribe(::bgs::protocol::user_manager::v1::SubscribeRequest const* request, ::bgs::protocol::user_manager::v1::SubscribeResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.Subscribe({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 UserManagerService::HandleAddRecentPlayers(::bgs::protocol::user_manager::v1::AddRecentPlayersRequest const* request, ::bgs::protocol::user_manager::v1::AddRecentPlayersResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.AddRecentPlayers({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 UserManagerService::HandleClearRecentPlayers(::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest const* request, ::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.ClearRecentPlayers({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 UserManagerService::HandleBlockPlayer(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.BlockPlayer({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 UserManagerService::HandleUnblockPlayer(::bgs::protocol::user_manager::v1::UnblockPlayerRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.UnblockPlayer({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 UserManagerService::HandleBlockPlayerForSession(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.BlockPlayerForSession({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 UserManagerService::HandleLoadBlockList(::bgs::protocol::EntityId const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.LoadBlockList({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 UserManagerService::HandleUnsubscribe(::bgs::protocol::user_manager::v1::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerService.Unsubscribe({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+// ===================================================================
+
+google::protobuf::ServiceDescriptor const* UserManagerListener::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return UserManagerListener_descriptor_;
+}
+
+void UserManagerListener::OnBlockedPlayerAdded(::bgs::protocol::user_manager::v1::BlockedPlayerAddedNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerListener.OnBlockedPlayerAdded(bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 1, request);
+}
+
+void UserManagerListener::OnBlockedPlayerRemoved(::bgs::protocol::user_manager::v1::BlockedPlayerRemovedNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerListener.OnBlockedPlayerRemoved(bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 2, request);
+}
+
+void UserManagerListener::OnRecentPlayersAdded(::bgs::protocol::user_manager::v1::RecentPlayersAddedNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerListener.OnRecentPlayersAdded(bgs.protocol.user_manager.v1.RecentPlayersAddedNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 11, request);
+}
+
+void UserManagerListener::OnRecentPlayersRemoved(::bgs::protocol::user_manager::v1::RecentPlayersRemovedNotification const* request) { 
+  TC_LOG_DEBUG("service.protobuf", "%s Server called client method UserManagerListener.OnRecentPlayersRemoved(bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification{ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  SendRequest(service_hash_, 12, request);
+}
+
+void UserManagerListener::CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) {
+  switch(methodId) {
+    case 1: {
+      ::bgs::protocol::user_manager::v1::BlockedPlayerAddedNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerListener.OnBlockedPlayerAdded server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 1, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnBlockedPlayerAdded(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerListener.OnBlockedPlayerAdded(bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 1, token, status);
+      break;
+    }
+    case 2: {
+      ::bgs::protocol::user_manager::v1::BlockedPlayerRemovedNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerListener.OnBlockedPlayerRemoved server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 2, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnBlockedPlayerRemoved(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerListener.OnBlockedPlayerRemoved(bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 2, token, status);
+      break;
+    }
+    case 11: {
+      ::bgs::protocol::user_manager::v1::RecentPlayersAddedNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerListener.OnRecentPlayersAdded server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 11, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnRecentPlayersAdded(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerListener.OnRecentPlayersAdded(bgs.protocol.user_manager.v1.RecentPlayersAddedNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 11, token, status);
+      break;
+    }
+    case 12: {
+      ::bgs::protocol::user_manager::v1::RecentPlayersRemovedNotification request;
+      if (!request.ParseFromArray(buffer.GetReadPointer(), buffer.GetActiveSize())) {
+        TC_LOG_DEBUG("service.protobuf", "%s Failed to parse request for UserManagerListener.OnRecentPlayersRemoved server method call.", GetCallerInfo().c_str());
+        SendResponse(service_hash_, 12, token, ERROR_RPC_MALFORMED_REQUEST);
+        return;
+      }
+
+      uint32 status = HandleOnRecentPlayersRemoved(&request);
+      TC_LOG_DEBUG("service.protobuf", "%s Client called server method UserManagerListener.OnRecentPlayersRemoved(bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification{ %s }) status %u.",
+        GetCallerInfo().c_str(), request.ShortDebugString().c_str(), status);
+      if (status)
+        SendResponse(service_hash_, 12, token, status);
+      break;
+    }
+    default:
+      TC_LOG_ERROR("service.protobuf", "Bad method id %u.", methodId);
+      SendResponse(service_hash_, methodId, token, ERROR_RPC_INVALID_METHOD);
+      break;
+    }
+}
+
+uint32 UserManagerListener::HandleOnBlockedPlayerAdded(::bgs::protocol::user_manager::v1::BlockedPlayerAddedNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerListener.OnBlockedPlayerAdded({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 UserManagerListener::HandleOnBlockedPlayerRemoved(::bgs::protocol::user_manager::v1::BlockedPlayerRemovedNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerListener.OnBlockedPlayerRemoved({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 UserManagerListener::HandleOnRecentPlayersAdded(::bgs::protocol::user_manager::v1::RecentPlayersAddedNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerListener.OnRecentPlayersAdded({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+uint32 UserManagerListener::HandleOnRecentPlayersRemoved(::bgs::protocol::user_manager::v1::RecentPlayersRemovedNotification const* request) {
+  TC_LOG_ERROR("service.protobuf", "%s Client tried to call not implemented method UserManagerListener.OnRecentPlayersRemoved({ %s })",
+    GetCallerInfo().c_str(), request->ShortDebugString().c_str());
+  return ERROR_RPC_NOT_IMPLEMENTED;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace user_manager
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/user_manager_service.pb.h b/src/server/proto/Client/user_manager_service.pb.h
new file mode 100644
index 00000000000..a51ac759561
--- /dev/null
+++ b/src/server/proto/Client/user_manager_service.pb.h
@@ -0,0 +1,2411 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: user_manager_service.proto
+
+#ifndef PROTOBUF_user_5fmanager_5fservice_2eproto__INCLUDED
+#define PROTOBUF_user_5fmanager_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 "user_manager_types.pb.h"
+#include "entity_types.pb.h"
+#include "role_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 user_manager {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto();
+void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto();
+
+class SubscribeRequest;
+class SubscribeResponse;
+class UnsubscribeRequest;
+class AddRecentPlayersRequest;
+class AddRecentPlayersResponse;
+class ClearRecentPlayersRequest;
+class ClearRecentPlayersResponse;
+class BlockPlayerRequest;
+class UnblockPlayerRequest;
+class BlockedPlayerAddedNotification;
+class BlockedPlayerRemovedNotification;
+class RecentPlayersAddedNotification;
+class RecentPlayersRemovedNotification;
+
+// ===================================================================
+
+class TC_SHARED_API SubscribeRequest : public ::google::protobuf::Message {
+ public:
+  SubscribeRequest();
+  virtual ~SubscribeRequest();
+
+  SubscribeRequest(const SubscribeRequest& from);
+
+  inline SubscribeRequest& operator=(const SubscribeRequest& 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 SubscribeRequest& default_instance();
+
+  void Swap(SubscribeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscribeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscribeRequest& from);
+  void MergeFrom(const SubscribeRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required uint64 object_id = 2;
+  inline bool has_object_id() const;
+  inline void clear_object_id();
+  static const int kObjectIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 object_id() const;
+  inline void set_object_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.SubscribeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_object_id();
+  inline void clear_has_object_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::uint64 object_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscribeRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API SubscribeResponse : public ::google::protobuf::Message {
+ public:
+  SubscribeResponse();
+  virtual ~SubscribeResponse();
+
+  SubscribeResponse(const SubscribeResponse& from);
+
+  inline SubscribeResponse& operator=(const SubscribeResponse& 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 SubscribeResponse& default_instance();
+
+  void Swap(SubscribeResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  SubscribeResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const SubscribeResponse& from);
+  void MergeFrom(const SubscribeResponse& 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.user_manager.v1.BlockedPlayer blocked_players = 1;
+  inline int blocked_players_size() const;
+  inline void clear_blocked_players();
+  static const int kBlockedPlayersFieldNumber = 1;
+  inline const ::bgs::protocol::user_manager::v1::BlockedPlayer& blocked_players(int index) const;
+  inline ::bgs::protocol::user_manager::v1::BlockedPlayer* mutable_blocked_players(int index);
+  inline ::bgs::protocol::user_manager::v1::BlockedPlayer* add_blocked_players();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::BlockedPlayer >&
+      blocked_players() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::BlockedPlayer >*
+      mutable_blocked_players();
+
+  // repeated .bgs.protocol.user_manager.v1.RecentPlayer recent_players = 2;
+  inline int recent_players_size() const;
+  inline void clear_recent_players();
+  static const int kRecentPlayersFieldNumber = 2;
+  inline const ::bgs::protocol::user_manager::v1::RecentPlayer& recent_players(int index) const;
+  inline ::bgs::protocol::user_manager::v1::RecentPlayer* mutable_recent_players(int index);
+  inline ::bgs::protocol::user_manager::v1::RecentPlayer* add_recent_players();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >&
+      recent_players() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >*
+      mutable_recent_players();
+
+  // repeated .bgs.protocol.Role role = 3;
+  inline int role_size() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 3;
+  inline const ::bgs::protocol::Role& role(int index) const;
+  inline ::bgs::protocol::Role* mutable_role(int index);
+  inline ::bgs::protocol::Role* add_role();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role >&
+      role() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role >*
+      mutable_role();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.SubscribeResponse)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::BlockedPlayer > blocked_players_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer > recent_players_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role > role_;
+  friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static SubscribeResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API UnsubscribeRequest : public ::google::protobuf::Message {
+ public:
+  UnsubscribeRequest();
+  virtual ~UnsubscribeRequest();
+
+  UnsubscribeRequest(const UnsubscribeRequest& from);
+
+  inline UnsubscribeRequest& operator=(const UnsubscribeRequest& 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 UnsubscribeRequest& default_instance();
+
+  void Swap(UnsubscribeRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UnsubscribeRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UnsubscribeRequest& from);
+  void MergeFrom(const UnsubscribeRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // optional uint64 object_id = 2;
+  inline bool has_object_id() const;
+  inline void clear_object_id();
+  static const int kObjectIdFieldNumber = 2;
+  inline ::google::protobuf::uint64 object_id() const;
+  inline void set_object_id(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.UnsubscribeRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_object_id();
+  inline void clear_has_object_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::uint64 object_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static UnsubscribeRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AddRecentPlayersRequest : public ::google::protobuf::Message {
+ public:
+  AddRecentPlayersRequest();
+  virtual ~AddRecentPlayersRequest();
+
+  AddRecentPlayersRequest(const AddRecentPlayersRequest& from);
+
+  inline AddRecentPlayersRequest& operator=(const AddRecentPlayersRequest& 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 AddRecentPlayersRequest& default_instance();
+
+  void Swap(AddRecentPlayersRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  AddRecentPlayersRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AddRecentPlayersRequest& from);
+  void MergeFrom(const AddRecentPlayersRequest& 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.user_manager.v1.RecentPlayer players = 1;
+  inline int players_size() const;
+  inline void clear_players();
+  static const int kPlayersFieldNumber = 1;
+  inline const ::bgs::protocol::user_manager::v1::RecentPlayer& players(int index) const;
+  inline ::bgs::protocol::user_manager::v1::RecentPlayer* mutable_players(int index);
+  inline ::bgs::protocol::user_manager::v1::RecentPlayer* add_players();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >&
+      players() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >*
+      mutable_players();
+
+  // optional .bgs.protocol.EntityId agent_id = 2;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // optional uint32 program = 3;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 3;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.AddRecentPlayersRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  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::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer > players_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::uint32 program_;
+  friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static AddRecentPlayersRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API AddRecentPlayersResponse : public ::google::protobuf::Message {
+ public:
+  AddRecentPlayersResponse();
+  virtual ~AddRecentPlayersResponse();
+
+  AddRecentPlayersResponse(const AddRecentPlayersResponse& from);
+
+  inline AddRecentPlayersResponse& operator=(const AddRecentPlayersResponse& 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 AddRecentPlayersResponse& default_instance();
+
+  void Swap(AddRecentPlayersResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  AddRecentPlayersResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const AddRecentPlayersResponse& from);
+  void MergeFrom(const AddRecentPlayersResponse& 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.user_manager.v1.RecentPlayer players_added = 1;
+  inline int players_added_size() const;
+  inline void clear_players_added();
+  static const int kPlayersAddedFieldNumber = 1;
+  inline const ::bgs::protocol::user_manager::v1::RecentPlayer& players_added(int index) const;
+  inline ::bgs::protocol::user_manager::v1::RecentPlayer* mutable_players_added(int index);
+  inline ::bgs::protocol::user_manager::v1::RecentPlayer* add_players_added();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >&
+      players_added() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >*
+      mutable_players_added();
+
+  // repeated fixed32 players_removed = 3;
+  inline int players_removed_size() const;
+  inline void clear_players_removed();
+  static const int kPlayersRemovedFieldNumber = 3;
+  inline ::google::protobuf::uint32 players_removed(int index) const;
+  inline void set_players_removed(int index, ::google::protobuf::uint32 value);
+  inline void add_players_removed(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      players_removed() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_players_removed();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.AddRecentPlayersResponse)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer > players_added_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > players_removed_;
+  friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static AddRecentPlayersResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ClearRecentPlayersRequest : public ::google::protobuf::Message {
+ public:
+  ClearRecentPlayersRequest();
+  virtual ~ClearRecentPlayersRequest();
+
+  ClearRecentPlayersRequest(const ClearRecentPlayersRequest& from);
+
+  inline ClearRecentPlayersRequest& operator=(const ClearRecentPlayersRequest& 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 ClearRecentPlayersRequest& default_instance();
+
+  void Swap(ClearRecentPlayersRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  ClearRecentPlayersRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClearRecentPlayersRequest& from);
+  void MergeFrom(const ClearRecentPlayersRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // optional uint32 program = 2;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 2;
+  inline ::google::protobuf::uint32 program() const;
+  inline void set_program(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  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_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::google::protobuf::uint32 program_;
+  friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClearRecentPlayersRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API ClearRecentPlayersResponse : public ::google::protobuf::Message {
+ public:
+  ClearRecentPlayersResponse();
+  virtual ~ClearRecentPlayersResponse();
+
+  ClearRecentPlayersResponse(const ClearRecentPlayersResponse& from);
+
+  inline ClearRecentPlayersResponse& operator=(const ClearRecentPlayersResponse& 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 ClearRecentPlayersResponse& default_instance();
+
+  void Swap(ClearRecentPlayersResponse* other);
+
+  // implements Message ----------------------------------------------
+
+  ClearRecentPlayersResponse* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const ClearRecentPlayersResponse& from);
+  void MergeFrom(const ClearRecentPlayersResponse& 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 fixed32 players_removed = 1;
+  inline int players_removed_size() const;
+  inline void clear_players_removed();
+  static const int kPlayersRemovedFieldNumber = 1;
+  inline ::google::protobuf::uint32 players_removed(int index) const;
+  inline void set_players_removed(int index, ::google::protobuf::uint32 value);
+  inline void add_players_removed(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      players_removed() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_players_removed();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > players_removed_;
+  friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static ClearRecentPlayersResponse* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API BlockPlayerRequest : public ::google::protobuf::Message {
+ public:
+  BlockPlayerRequest();
+  virtual ~BlockPlayerRequest();
+
+  BlockPlayerRequest(const BlockPlayerRequest& from);
+
+  inline BlockPlayerRequest& operator=(const BlockPlayerRequest& 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 BlockPlayerRequest& default_instance();
+
+  void Swap(BlockPlayerRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  BlockPlayerRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const BlockPlayerRequest& from);
+  void MergeFrom(const BlockPlayerRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& target_id() const;
+  inline ::bgs::protocol::EntityId* mutable_target_id();
+  inline ::bgs::protocol::EntityId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id);
+
+  // optional uint32 role = 3;
+  inline bool has_role() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 3;
+  inline ::google::protobuf::uint32 role() const;
+  inline void set_role(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.BlockPlayerRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+  inline void set_has_role();
+  inline void clear_has_role();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::EntityId* target_id_;
+  ::google::protobuf::uint32 role_;
+  friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static BlockPlayerRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API UnblockPlayerRequest : public ::google::protobuf::Message {
+ public:
+  UnblockPlayerRequest();
+  virtual ~UnblockPlayerRequest();
+
+  UnblockPlayerRequest(const UnblockPlayerRequest& from);
+
+  inline UnblockPlayerRequest& operator=(const UnblockPlayerRequest& 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 UnblockPlayerRequest& default_instance();
+
+  void Swap(UnblockPlayerRequest* other);
+
+  // implements Message ----------------------------------------------
+
+  UnblockPlayerRequest* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const UnblockPlayerRequest& from);
+  void MergeFrom(const UnblockPlayerRequest& 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.EntityId agent_id = 1;
+  inline bool has_agent_id() const;
+  inline void clear_agent_id();
+  static const int kAgentIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& agent_id() const;
+  inline ::bgs::protocol::EntityId* mutable_agent_id();
+  inline ::bgs::protocol::EntityId* release_agent_id();
+  inline void set_allocated_agent_id(::bgs::protocol::EntityId* agent_id);
+
+  // required .bgs.protocol.EntityId target_id = 2;
+  inline bool has_target_id() const;
+  inline void clear_target_id();
+  static const int kTargetIdFieldNumber = 2;
+  inline const ::bgs::protocol::EntityId& target_id() const;
+  inline ::bgs::protocol::EntityId* mutable_target_id();
+  inline ::bgs::protocol::EntityId* release_target_id();
+  inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.UnblockPlayerRequest)
+ private:
+  inline void set_has_agent_id();
+  inline void clear_has_agent_id();
+  inline void set_has_target_id();
+  inline void clear_has_target_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* agent_id_;
+  ::bgs::protocol::EntityId* target_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static UnblockPlayerRequest* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API BlockedPlayerAddedNotification : public ::google::protobuf::Message {
+ public:
+  BlockedPlayerAddedNotification();
+  virtual ~BlockedPlayerAddedNotification();
+
+  BlockedPlayerAddedNotification(const BlockedPlayerAddedNotification& from);
+
+  inline BlockedPlayerAddedNotification& operator=(const BlockedPlayerAddedNotification& 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 BlockedPlayerAddedNotification& default_instance();
+
+  void Swap(BlockedPlayerAddedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  BlockedPlayerAddedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const BlockedPlayerAddedNotification& from);
+  void MergeFrom(const BlockedPlayerAddedNotification& 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.user_manager.v1.BlockedPlayer player = 1;
+  inline bool has_player() const;
+  inline void clear_player();
+  static const int kPlayerFieldNumber = 1;
+  inline const ::bgs::protocol::user_manager::v1::BlockedPlayer& player() const;
+  inline ::bgs::protocol::user_manager::v1::BlockedPlayer* mutable_player();
+  inline ::bgs::protocol::user_manager::v1::BlockedPlayer* release_player();
+  inline void set_allocated_player(::bgs::protocol::user_manager::v1::BlockedPlayer* player);
+
+  // 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);
+
+  // optional .bgs.protocol.EntityId account_id = 3;
+  inline bool has_account_id() const;
+  inline void clear_account_id();
+  static const int kAccountIdFieldNumber = 3;
+  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);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification)
+ private:
+  inline void set_has_player();
+  inline void clear_has_player();
+  inline void set_has_game_account_id();
+  inline void clear_has_game_account_id();
+  inline void set_has_account_id();
+  inline void clear_has_account_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::user_manager::v1::BlockedPlayer* player_;
+  ::bgs::protocol::EntityId* game_account_id_;
+  ::bgs::protocol::EntityId* account_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static BlockedPlayerAddedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API BlockedPlayerRemovedNotification : public ::google::protobuf::Message {
+ public:
+  BlockedPlayerRemovedNotification();
+  virtual ~BlockedPlayerRemovedNotification();
+
+  BlockedPlayerRemovedNotification(const BlockedPlayerRemovedNotification& from);
+
+  inline BlockedPlayerRemovedNotification& operator=(const BlockedPlayerRemovedNotification& 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 BlockedPlayerRemovedNotification& default_instance();
+
+  void Swap(BlockedPlayerRemovedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  BlockedPlayerRemovedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const BlockedPlayerRemovedNotification& from);
+  void MergeFrom(const BlockedPlayerRemovedNotification& 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.user_manager.v1.BlockedPlayer player = 1;
+  inline bool has_player() const;
+  inline void clear_player();
+  static const int kPlayerFieldNumber = 1;
+  inline const ::bgs::protocol::user_manager::v1::BlockedPlayer& player() const;
+  inline ::bgs::protocol::user_manager::v1::BlockedPlayer* mutable_player();
+  inline ::bgs::protocol::user_manager::v1::BlockedPlayer* release_player();
+  inline void set_allocated_player(::bgs::protocol::user_manager::v1::BlockedPlayer* player);
+
+  // 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);
+
+  // optional .bgs.protocol.EntityId account_id = 3;
+  inline bool has_account_id() const;
+  inline void clear_account_id();
+  static const int kAccountIdFieldNumber = 3;
+  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);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification)
+ private:
+  inline void set_has_player();
+  inline void clear_has_player();
+  inline void set_has_game_account_id();
+  inline void clear_has_game_account_id();
+  inline void set_has_account_id();
+  inline void clear_has_account_id();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::user_manager::v1::BlockedPlayer* player_;
+  ::bgs::protocol::EntityId* game_account_id_;
+  ::bgs::protocol::EntityId* account_id_;
+  friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static BlockedPlayerRemovedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API RecentPlayersAddedNotification : public ::google::protobuf::Message {
+ public:
+  RecentPlayersAddedNotification();
+  virtual ~RecentPlayersAddedNotification();
+
+  RecentPlayersAddedNotification(const RecentPlayersAddedNotification& from);
+
+  inline RecentPlayersAddedNotification& operator=(const RecentPlayersAddedNotification& 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 RecentPlayersAddedNotification& default_instance();
+
+  void Swap(RecentPlayersAddedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  RecentPlayersAddedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RecentPlayersAddedNotification& from);
+  void MergeFrom(const RecentPlayersAddedNotification& 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.user_manager.v1.RecentPlayer player = 1;
+  inline int player_size() const;
+  inline void clear_player();
+  static const int kPlayerFieldNumber = 1;
+  inline const ::bgs::protocol::user_manager::v1::RecentPlayer& player(int index) const;
+  inline ::bgs::protocol::user_manager::v1::RecentPlayer* mutable_player(int index);
+  inline ::bgs::protocol::user_manager::v1::RecentPlayer* add_player();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >&
+      player() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >*
+      mutable_player();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer > player_;
+  friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static RecentPlayersAddedNotification* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API RecentPlayersRemovedNotification : public ::google::protobuf::Message {
+ public:
+  RecentPlayersRemovedNotification();
+  virtual ~RecentPlayersRemovedNotification();
+
+  RecentPlayersRemovedNotification(const RecentPlayersRemovedNotification& from);
+
+  inline RecentPlayersRemovedNotification& operator=(const RecentPlayersRemovedNotification& 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 RecentPlayersRemovedNotification& default_instance();
+
+  void Swap(RecentPlayersRemovedNotification* other);
+
+  // implements Message ----------------------------------------------
+
+  RecentPlayersRemovedNotification* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RecentPlayersRemovedNotification& from);
+  void MergeFrom(const RecentPlayersRemovedNotification& 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.user_manager.v1.RecentPlayer player = 1;
+  inline int player_size() const;
+  inline void clear_player();
+  static const int kPlayerFieldNumber = 1;
+  inline const ::bgs::protocol::user_manager::v1::RecentPlayer& player(int index) const;
+  inline ::bgs::protocol::user_manager::v1::RecentPlayer* mutable_player(int index);
+  inline ::bgs::protocol::user_manager::v1::RecentPlayer* add_player();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >&
+      player() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >*
+      mutable_player();
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification)
+ private:
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer > player_;
+  friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_AssignDesc_user_5fmanager_5fservice_2eproto();
+  friend void protobuf_ShutdownFile_user_5fmanager_5fservice_2eproto();
+
+  void InitAsDefaultInstance();
+  static RecentPlayersRemovedNotification* default_instance_;
+};
+// ===================================================================
+
+class TC_SHARED_API UserManagerService : public ServiceBase
+{
+ public:
+
+  template<typename HashSelector>
+  explicit UserManagerService(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  typedef std::integral_constant<uint32, 0x3E19268Au> OriginalHash;
+  typedef std::integral_constant<uint32, 0x8EE5694Eu> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void Subscribe(::bgs::protocol::user_manager::v1::SubscribeRequest const* request, std::function<void(::bgs::protocol::user_manager::v1::SubscribeResponse const*)> responseCallback);
+  void AddRecentPlayers(::bgs::protocol::user_manager::v1::AddRecentPlayersRequest const* request, std::function<void(::bgs::protocol::user_manager::v1::AddRecentPlayersResponse const*)> responseCallback);
+  void ClearRecentPlayers(::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest const* request, std::function<void(::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse const*)> responseCallback);
+  void BlockPlayer(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void UnblockPlayer(::bgs::protocol::user_manager::v1::UnblockPlayerRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void BlockPlayerForSession(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void LoadBlockList(::bgs::protocol::EntityId const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  void Unsubscribe(::bgs::protocol::user_manager::v1::UnsubscribeRequest const* request, std::function<void(::bgs::protocol::NoData const*)> responseCallback);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleSubscribe(::bgs::protocol::user_manager::v1::SubscribeRequest const* request, ::bgs::protocol::user_manager::v1::SubscribeResponse* response);
+  virtual uint32 HandleAddRecentPlayers(::bgs::protocol::user_manager::v1::AddRecentPlayersRequest const* request, ::bgs::protocol::user_manager::v1::AddRecentPlayersResponse* response);
+  virtual uint32 HandleClearRecentPlayers(::bgs::protocol::user_manager::v1::ClearRecentPlayersRequest const* request, ::bgs::protocol::user_manager::v1::ClearRecentPlayersResponse* response);
+  virtual uint32 HandleBlockPlayer(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleUnblockPlayer(::bgs::protocol::user_manager::v1::UnblockPlayerRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleBlockPlayerForSession(::bgs::protocol::user_manager::v1::BlockPlayerRequest const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleLoadBlockList(::bgs::protocol::EntityId const* request, ::bgs::protocol::NoData* response);
+  virtual uint32 HandleUnsubscribe(::bgs::protocol::user_manager::v1::UnsubscribeRequest const* request, ::bgs::protocol::NoData* response);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(UserManagerService);
+};
+
+// -------------------------------------------------------------------
+
+class TC_SHARED_API UserManagerListener : public ServiceBase
+{
+ public:
+
+  template<typename HashSelector>
+  explicit UserManagerListener(HashSelector) : service_hash_(HashSelector::Result::value) { }
+
+  typedef std::integral_constant<uint32, 0xBC872C22u> OriginalHash;
+  typedef std::integral_constant<uint32, 0xB3426BB3u> NameHash;
+
+  static google::protobuf::ServiceDescriptor const* descriptor();
+
+  // client methods --------------------------------------------------
+
+  void OnBlockedPlayerAdded(::bgs::protocol::user_manager::v1::BlockedPlayerAddedNotification const* request);
+  void OnBlockedPlayerRemoved(::bgs::protocol::user_manager::v1::BlockedPlayerRemovedNotification const* request);
+  void OnRecentPlayersAdded(::bgs::protocol::user_manager::v1::RecentPlayersAddedNotification const* request);
+  void OnRecentPlayersRemoved(::bgs::protocol::user_manager::v1::RecentPlayersRemovedNotification const* request);
+  // server methods --------------------------------------------------
+
+  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) override final;
+
+ protected:
+  virtual uint32 HandleOnBlockedPlayerAdded(::bgs::protocol::user_manager::v1::BlockedPlayerAddedNotification const* request);
+  virtual uint32 HandleOnBlockedPlayerRemoved(::bgs::protocol::user_manager::v1::BlockedPlayerRemovedNotification const* request);
+  virtual uint32 HandleOnRecentPlayersAdded(::bgs::protocol::user_manager::v1::RecentPlayersAddedNotification const* request);
+  virtual uint32 HandleOnRecentPlayersRemoved(::bgs::protocol::user_manager::v1::RecentPlayersRemovedNotification const* request);
+
+ private:
+  uint32 service_hash_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(UserManagerListener);
+};
+
+// ===================================================================
+
+
+// ===================================================================
+
+// SubscribeRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool SubscribeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SubscribeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SubscribeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SubscribeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& SubscribeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.SubscribeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* SubscribeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.SubscribeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* SubscribeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void SubscribeRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.SubscribeRequest.agent_id)
+}
+
+// required uint64 object_id = 2;
+inline bool SubscribeRequest::has_object_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SubscribeRequest::set_has_object_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SubscribeRequest::clear_has_object_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SubscribeRequest::clear_object_id() {
+  object_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_object_id();
+}
+inline ::google::protobuf::uint64 SubscribeRequest::object_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.SubscribeRequest.object_id)
+  return object_id_;
+}
+inline void SubscribeRequest::set_object_id(::google::protobuf::uint64 value) {
+  set_has_object_id();
+  object_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.SubscribeRequest.object_id)
+}
+
+// -------------------------------------------------------------------
+
+// SubscribeResponse
+
+// repeated .bgs.protocol.user_manager.v1.BlockedPlayer blocked_players = 1;
+inline int SubscribeResponse::blocked_players_size() const {
+  return blocked_players_.size();
+}
+inline void SubscribeResponse::clear_blocked_players() {
+  blocked_players_.Clear();
+}
+inline const ::bgs::protocol::user_manager::v1::BlockedPlayer& SubscribeResponse::blocked_players(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.SubscribeResponse.blocked_players)
+  return blocked_players_.Get(index);
+}
+inline ::bgs::protocol::user_manager::v1::BlockedPlayer* SubscribeResponse::mutable_blocked_players(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.SubscribeResponse.blocked_players)
+  return blocked_players_.Mutable(index);
+}
+inline ::bgs::protocol::user_manager::v1::BlockedPlayer* SubscribeResponse::add_blocked_players() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.SubscribeResponse.blocked_players)
+  return blocked_players_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::BlockedPlayer >&
+SubscribeResponse::blocked_players() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.SubscribeResponse.blocked_players)
+  return blocked_players_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::BlockedPlayer >*
+SubscribeResponse::mutable_blocked_players() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.SubscribeResponse.blocked_players)
+  return &blocked_players_;
+}
+
+// repeated .bgs.protocol.user_manager.v1.RecentPlayer recent_players = 2;
+inline int SubscribeResponse::recent_players_size() const {
+  return recent_players_.size();
+}
+inline void SubscribeResponse::clear_recent_players() {
+  recent_players_.Clear();
+}
+inline const ::bgs::protocol::user_manager::v1::RecentPlayer& SubscribeResponse::recent_players(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.SubscribeResponse.recent_players)
+  return recent_players_.Get(index);
+}
+inline ::bgs::protocol::user_manager::v1::RecentPlayer* SubscribeResponse::mutable_recent_players(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.SubscribeResponse.recent_players)
+  return recent_players_.Mutable(index);
+}
+inline ::bgs::protocol::user_manager::v1::RecentPlayer* SubscribeResponse::add_recent_players() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.SubscribeResponse.recent_players)
+  return recent_players_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >&
+SubscribeResponse::recent_players() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.SubscribeResponse.recent_players)
+  return recent_players_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >*
+SubscribeResponse::mutable_recent_players() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.SubscribeResponse.recent_players)
+  return &recent_players_;
+}
+
+// repeated .bgs.protocol.Role role = 3;
+inline int SubscribeResponse::role_size() const {
+  return role_.size();
+}
+inline void SubscribeResponse::clear_role() {
+  role_.Clear();
+}
+inline const ::bgs::protocol::Role& SubscribeResponse::role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.SubscribeResponse.role)
+  return role_.Get(index);
+}
+inline ::bgs::protocol::Role* SubscribeResponse::mutable_role(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.SubscribeResponse.role)
+  return role_.Mutable(index);
+}
+inline ::bgs::protocol::Role* SubscribeResponse::add_role() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.SubscribeResponse.role)
+  return role_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role >&
+SubscribeResponse::role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.SubscribeResponse.role)
+  return role_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Role >*
+SubscribeResponse::mutable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.SubscribeResponse.role)
+  return &role_;
+}
+
+// -------------------------------------------------------------------
+
+// UnsubscribeRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool UnsubscribeRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UnsubscribeRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UnsubscribeRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UnsubscribeRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& UnsubscribeRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.UnsubscribeRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* UnsubscribeRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.UnsubscribeRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* UnsubscribeRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UnsubscribeRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.UnsubscribeRequest.agent_id)
+}
+
+// optional uint64 object_id = 2;
+inline bool UnsubscribeRequest::has_object_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UnsubscribeRequest::set_has_object_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UnsubscribeRequest::clear_has_object_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UnsubscribeRequest::clear_object_id() {
+  object_id_ = GOOGLE_ULONGLONG(0);
+  clear_has_object_id();
+}
+inline ::google::protobuf::uint64 UnsubscribeRequest::object_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.UnsubscribeRequest.object_id)
+  return object_id_;
+}
+inline void UnsubscribeRequest::set_object_id(::google::protobuf::uint64 value) {
+  set_has_object_id();
+  object_id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.UnsubscribeRequest.object_id)
+}
+
+// -------------------------------------------------------------------
+
+// AddRecentPlayersRequest
+
+// repeated .bgs.protocol.user_manager.v1.RecentPlayer players = 1;
+inline int AddRecentPlayersRequest::players_size() const {
+  return players_.size();
+}
+inline void AddRecentPlayersRequest::clear_players() {
+  players_.Clear();
+}
+inline const ::bgs::protocol::user_manager::v1::RecentPlayer& AddRecentPlayersRequest::players(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.players)
+  return players_.Get(index);
+}
+inline ::bgs::protocol::user_manager::v1::RecentPlayer* AddRecentPlayersRequest::mutable_players(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.players)
+  return players_.Mutable(index);
+}
+inline ::bgs::protocol::user_manager::v1::RecentPlayer* AddRecentPlayersRequest::add_players() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.players)
+  return players_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >&
+AddRecentPlayersRequest::players() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.players)
+  return players_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >*
+AddRecentPlayersRequest::mutable_players() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.players)
+  return &players_;
+}
+
+// optional .bgs.protocol.EntityId agent_id = 2;
+inline bool AddRecentPlayersRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void AddRecentPlayersRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void AddRecentPlayersRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void AddRecentPlayersRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& AddRecentPlayersRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* AddRecentPlayersRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* AddRecentPlayersRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void AddRecentPlayersRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.agent_id)
+}
+
+// optional uint32 program = 3;
+inline bool AddRecentPlayersRequest::has_program() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void AddRecentPlayersRequest::set_has_program() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void AddRecentPlayersRequest::clear_has_program() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void AddRecentPlayersRequest::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 AddRecentPlayersRequest::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.program)
+  return program_;
+}
+inline void AddRecentPlayersRequest::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.AddRecentPlayersRequest.program)
+}
+
+// -------------------------------------------------------------------
+
+// AddRecentPlayersResponse
+
+// repeated .bgs.protocol.user_manager.v1.RecentPlayer players_added = 1;
+inline int AddRecentPlayersResponse::players_added_size() const {
+  return players_added_.size();
+}
+inline void AddRecentPlayersResponse::clear_players_added() {
+  players_added_.Clear();
+}
+inline const ::bgs::protocol::user_manager::v1::RecentPlayer& AddRecentPlayersResponse::players_added(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_added)
+  return players_added_.Get(index);
+}
+inline ::bgs::protocol::user_manager::v1::RecentPlayer* AddRecentPlayersResponse::mutable_players_added(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_added)
+  return players_added_.Mutable(index);
+}
+inline ::bgs::protocol::user_manager::v1::RecentPlayer* AddRecentPlayersResponse::add_players_added() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_added)
+  return players_added_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >&
+AddRecentPlayersResponse::players_added() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_added)
+  return players_added_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >*
+AddRecentPlayersResponse::mutable_players_added() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_added)
+  return &players_added_;
+}
+
+// repeated fixed32 players_removed = 3;
+inline int AddRecentPlayersResponse::players_removed_size() const {
+  return players_removed_.size();
+}
+inline void AddRecentPlayersResponse::clear_players_removed() {
+  players_removed_.Clear();
+}
+inline ::google::protobuf::uint32 AddRecentPlayersResponse::players_removed(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_removed)
+  return players_removed_.Get(index);
+}
+inline void AddRecentPlayersResponse::set_players_removed(int index, ::google::protobuf::uint32 value) {
+  players_removed_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_removed)
+}
+inline void AddRecentPlayersResponse::add_players_removed(::google::protobuf::uint32 value) {
+  players_removed_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_removed)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+AddRecentPlayersResponse::players_removed() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_removed)
+  return players_removed_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+AddRecentPlayersResponse::mutable_players_removed() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.AddRecentPlayersResponse.players_removed)
+  return &players_removed_;
+}
+
+// -------------------------------------------------------------------
+
+// ClearRecentPlayersRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool ClearRecentPlayersRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ClearRecentPlayersRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ClearRecentPlayersRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ClearRecentPlayersRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& ClearRecentPlayersRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* ClearRecentPlayersRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* ClearRecentPlayersRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void ClearRecentPlayersRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest.agent_id)
+}
+
+// optional uint32 program = 2;
+inline bool ClearRecentPlayersRequest::has_program() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ClearRecentPlayersRequest::set_has_program() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ClearRecentPlayersRequest::clear_has_program() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ClearRecentPlayersRequest::clear_program() {
+  program_ = 0u;
+  clear_has_program();
+}
+inline ::google::protobuf::uint32 ClearRecentPlayersRequest::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest.program)
+  return program_;
+}
+inline void ClearRecentPlayersRequest::set_program(::google::protobuf::uint32 value) {
+  set_has_program();
+  program_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.ClearRecentPlayersRequest.program)
+}
+
+// -------------------------------------------------------------------
+
+// ClearRecentPlayersResponse
+
+// repeated fixed32 players_removed = 1;
+inline int ClearRecentPlayersResponse::players_removed_size() const {
+  return players_removed_.size();
+}
+inline void ClearRecentPlayersResponse::clear_players_removed() {
+  players_removed_.Clear();
+}
+inline ::google::protobuf::uint32 ClearRecentPlayersResponse::players_removed(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse.players_removed)
+  return players_removed_.Get(index);
+}
+inline void ClearRecentPlayersResponse::set_players_removed(int index, ::google::protobuf::uint32 value) {
+  players_removed_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse.players_removed)
+}
+inline void ClearRecentPlayersResponse::add_players_removed(::google::protobuf::uint32 value) {
+  players_removed_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse.players_removed)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+ClearRecentPlayersResponse::players_removed() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse.players_removed)
+  return players_removed_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+ClearRecentPlayersResponse::mutable_players_removed() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.ClearRecentPlayersResponse.players_removed)
+  return &players_removed_;
+}
+
+// -------------------------------------------------------------------
+
+// BlockPlayerRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool BlockPlayerRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void BlockPlayerRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void BlockPlayerRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void BlockPlayerRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& BlockPlayerRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockPlayerRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* BlockPlayerRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockPlayerRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* BlockPlayerRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void BlockPlayerRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.BlockPlayerRequest.agent_id)
+}
+
+// required .bgs.protocol.EntityId target_id = 2;
+inline bool BlockPlayerRequest::has_target_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void BlockPlayerRequest::set_has_target_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void BlockPlayerRequest::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void BlockPlayerRequest::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::EntityId& BlockPlayerRequest::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockPlayerRequest.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::EntityId* BlockPlayerRequest::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockPlayerRequest.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::EntityId* BlockPlayerRequest::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::EntityId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void BlockPlayerRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.BlockPlayerRequest.target_id)
+}
+
+// optional uint32 role = 3;
+inline bool BlockPlayerRequest::has_role() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void BlockPlayerRequest::set_has_role() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void BlockPlayerRequest::clear_has_role() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void BlockPlayerRequest::clear_role() {
+  role_ = 0u;
+  clear_has_role();
+}
+inline ::google::protobuf::uint32 BlockPlayerRequest::role() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockPlayerRequest.role)
+  return role_;
+}
+inline void BlockPlayerRequest::set_role(::google::protobuf::uint32 value) {
+  set_has_role();
+  role_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.BlockPlayerRequest.role)
+}
+
+// -------------------------------------------------------------------
+
+// UnblockPlayerRequest
+
+// optional .bgs.protocol.EntityId agent_id = 1;
+inline bool UnblockPlayerRequest::has_agent_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UnblockPlayerRequest::set_has_agent_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UnblockPlayerRequest::clear_has_agent_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UnblockPlayerRequest::clear_agent_id() {
+  if (agent_id_ != NULL) agent_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_agent_id();
+}
+inline const ::bgs::protocol::EntityId& UnblockPlayerRequest::agent_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.UnblockPlayerRequest.agent_id)
+  return agent_id_ != NULL ? *agent_id_ : *default_instance_->agent_id_;
+}
+inline ::bgs::protocol::EntityId* UnblockPlayerRequest::mutable_agent_id() {
+  set_has_agent_id();
+  if (agent_id_ == NULL) agent_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.UnblockPlayerRequest.agent_id)
+  return agent_id_;
+}
+inline ::bgs::protocol::EntityId* UnblockPlayerRequest::release_agent_id() {
+  clear_has_agent_id();
+  ::bgs::protocol::EntityId* temp = agent_id_;
+  agent_id_ = NULL;
+  return temp;
+}
+inline void UnblockPlayerRequest::set_allocated_agent_id(::bgs::protocol::EntityId* agent_id) {
+  delete agent_id_;
+  agent_id_ = agent_id;
+  if (agent_id) {
+    set_has_agent_id();
+  } else {
+    clear_has_agent_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.UnblockPlayerRequest.agent_id)
+}
+
+// required .bgs.protocol.EntityId target_id = 2;
+inline bool UnblockPlayerRequest::has_target_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UnblockPlayerRequest::set_has_target_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UnblockPlayerRequest::clear_has_target_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UnblockPlayerRequest::clear_target_id() {
+  if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_target_id();
+}
+inline const ::bgs::protocol::EntityId& UnblockPlayerRequest::target_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.UnblockPlayerRequest.target_id)
+  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
+}
+inline ::bgs::protocol::EntityId* UnblockPlayerRequest::mutable_target_id() {
+  set_has_target_id();
+  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.UnblockPlayerRequest.target_id)
+  return target_id_;
+}
+inline ::bgs::protocol::EntityId* UnblockPlayerRequest::release_target_id() {
+  clear_has_target_id();
+  ::bgs::protocol::EntityId* temp = target_id_;
+  target_id_ = NULL;
+  return temp;
+}
+inline void UnblockPlayerRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
+  delete target_id_;
+  target_id_ = target_id;
+  if (target_id) {
+    set_has_target_id();
+  } else {
+    clear_has_target_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.UnblockPlayerRequest.target_id)
+}
+
+// -------------------------------------------------------------------
+
+// BlockedPlayerAddedNotification
+
+// required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1;
+inline bool BlockedPlayerAddedNotification::has_player() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void BlockedPlayerAddedNotification::set_has_player() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void BlockedPlayerAddedNotification::clear_has_player() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void BlockedPlayerAddedNotification::clear_player() {
+  if (player_ != NULL) player_->::bgs::protocol::user_manager::v1::BlockedPlayer::Clear();
+  clear_has_player();
+}
+inline const ::bgs::protocol::user_manager::v1::BlockedPlayer& BlockedPlayerAddedNotification::player() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification.player)
+  return player_ != NULL ? *player_ : *default_instance_->player_;
+}
+inline ::bgs::protocol::user_manager::v1::BlockedPlayer* BlockedPlayerAddedNotification::mutable_player() {
+  set_has_player();
+  if (player_ == NULL) player_ = new ::bgs::protocol::user_manager::v1::BlockedPlayer;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification.player)
+  return player_;
+}
+inline ::bgs::protocol::user_manager::v1::BlockedPlayer* BlockedPlayerAddedNotification::release_player() {
+  clear_has_player();
+  ::bgs::protocol::user_manager::v1::BlockedPlayer* temp = player_;
+  player_ = NULL;
+  return temp;
+}
+inline void BlockedPlayerAddedNotification::set_allocated_player(::bgs::protocol::user_manager::v1::BlockedPlayer* player) {
+  delete player_;
+  player_ = player;
+  if (player) {
+    set_has_player();
+  } else {
+    clear_has_player();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification.player)
+}
+
+// optional .bgs.protocol.EntityId game_account_id = 2;
+inline bool BlockedPlayerAddedNotification::has_game_account_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void BlockedPlayerAddedNotification::set_has_game_account_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void BlockedPlayerAddedNotification::clear_has_game_account_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void BlockedPlayerAddedNotification::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& BlockedPlayerAddedNotification::game_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification.game_account_id)
+  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
+}
+inline ::bgs::protocol::EntityId* BlockedPlayerAddedNotification::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.user_manager.v1.BlockedPlayerAddedNotification.game_account_id)
+  return game_account_id_;
+}
+inline ::bgs::protocol::EntityId* BlockedPlayerAddedNotification::release_game_account_id() {
+  clear_has_game_account_id();
+  ::bgs::protocol::EntityId* temp = game_account_id_;
+  game_account_id_ = NULL;
+  return temp;
+}
+inline void BlockedPlayerAddedNotification::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.user_manager.v1.BlockedPlayerAddedNotification.game_account_id)
+}
+
+// optional .bgs.protocol.EntityId account_id = 3;
+inline bool BlockedPlayerAddedNotification::has_account_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void BlockedPlayerAddedNotification::set_has_account_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void BlockedPlayerAddedNotification::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void BlockedPlayerAddedNotification::clear_account_id() {
+  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_account_id();
+}
+inline const ::bgs::protocol::EntityId& BlockedPlayerAddedNotification::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification.account_id)
+  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
+}
+inline ::bgs::protocol::EntityId* BlockedPlayerAddedNotification::mutable_account_id() {
+  set_has_account_id();
+  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockedPlayerAddedNotification.account_id)
+  return account_id_;
+}
+inline ::bgs::protocol::EntityId* BlockedPlayerAddedNotification::release_account_id() {
+  clear_has_account_id();
+  ::bgs::protocol::EntityId* temp = account_id_;
+  account_id_ = NULL;
+  return temp;
+}
+inline void BlockedPlayerAddedNotification::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.user_manager.v1.BlockedPlayerAddedNotification.account_id)
+}
+
+// -------------------------------------------------------------------
+
+// BlockedPlayerRemovedNotification
+
+// required .bgs.protocol.user_manager.v1.BlockedPlayer player = 1;
+inline bool BlockedPlayerRemovedNotification::has_player() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void BlockedPlayerRemovedNotification::set_has_player() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void BlockedPlayerRemovedNotification::clear_has_player() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void BlockedPlayerRemovedNotification::clear_player() {
+  if (player_ != NULL) player_->::bgs::protocol::user_manager::v1::BlockedPlayer::Clear();
+  clear_has_player();
+}
+inline const ::bgs::protocol::user_manager::v1::BlockedPlayer& BlockedPlayerRemovedNotification::player() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification.player)
+  return player_ != NULL ? *player_ : *default_instance_->player_;
+}
+inline ::bgs::protocol::user_manager::v1::BlockedPlayer* BlockedPlayerRemovedNotification::mutable_player() {
+  set_has_player();
+  if (player_ == NULL) player_ = new ::bgs::protocol::user_manager::v1::BlockedPlayer;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification.player)
+  return player_;
+}
+inline ::bgs::protocol::user_manager::v1::BlockedPlayer* BlockedPlayerRemovedNotification::release_player() {
+  clear_has_player();
+  ::bgs::protocol::user_manager::v1::BlockedPlayer* temp = player_;
+  player_ = NULL;
+  return temp;
+}
+inline void BlockedPlayerRemovedNotification::set_allocated_player(::bgs::protocol::user_manager::v1::BlockedPlayer* player) {
+  delete player_;
+  player_ = player;
+  if (player) {
+    set_has_player();
+  } else {
+    clear_has_player();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification.player)
+}
+
+// optional .bgs.protocol.EntityId game_account_id = 2;
+inline bool BlockedPlayerRemovedNotification::has_game_account_id() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void BlockedPlayerRemovedNotification::set_has_game_account_id() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void BlockedPlayerRemovedNotification::clear_has_game_account_id() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void BlockedPlayerRemovedNotification::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& BlockedPlayerRemovedNotification::game_account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification.game_account_id)
+  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
+}
+inline ::bgs::protocol::EntityId* BlockedPlayerRemovedNotification::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.user_manager.v1.BlockedPlayerRemovedNotification.game_account_id)
+  return game_account_id_;
+}
+inline ::bgs::protocol::EntityId* BlockedPlayerRemovedNotification::release_game_account_id() {
+  clear_has_game_account_id();
+  ::bgs::protocol::EntityId* temp = game_account_id_;
+  game_account_id_ = NULL;
+  return temp;
+}
+inline void BlockedPlayerRemovedNotification::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.user_manager.v1.BlockedPlayerRemovedNotification.game_account_id)
+}
+
+// optional .bgs.protocol.EntityId account_id = 3;
+inline bool BlockedPlayerRemovedNotification::has_account_id() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void BlockedPlayerRemovedNotification::set_has_account_id() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void BlockedPlayerRemovedNotification::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void BlockedPlayerRemovedNotification::clear_account_id() {
+  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_account_id();
+}
+inline const ::bgs::protocol::EntityId& BlockedPlayerRemovedNotification::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification.account_id)
+  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
+}
+inline ::bgs::protocol::EntityId* BlockedPlayerRemovedNotification::mutable_account_id() {
+  set_has_account_id();
+  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockedPlayerRemovedNotification.account_id)
+  return account_id_;
+}
+inline ::bgs::protocol::EntityId* BlockedPlayerRemovedNotification::release_account_id() {
+  clear_has_account_id();
+  ::bgs::protocol::EntityId* temp = account_id_;
+  account_id_ = NULL;
+  return temp;
+}
+inline void BlockedPlayerRemovedNotification::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.user_manager.v1.BlockedPlayerRemovedNotification.account_id)
+}
+
+// -------------------------------------------------------------------
+
+// RecentPlayersAddedNotification
+
+// repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1;
+inline int RecentPlayersAddedNotification::player_size() const {
+  return player_.size();
+}
+inline void RecentPlayersAddedNotification::clear_player() {
+  player_.Clear();
+}
+inline const ::bgs::protocol::user_manager::v1::RecentPlayer& RecentPlayersAddedNotification::player(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification.player)
+  return player_.Get(index);
+}
+inline ::bgs::protocol::user_manager::v1::RecentPlayer* RecentPlayersAddedNotification::mutable_player(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification.player)
+  return player_.Mutable(index);
+}
+inline ::bgs::protocol::user_manager::v1::RecentPlayer* RecentPlayersAddedNotification::add_player() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification.player)
+  return player_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >&
+RecentPlayersAddedNotification::player() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification.player)
+  return player_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >*
+RecentPlayersAddedNotification::mutable_player() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.RecentPlayersAddedNotification.player)
+  return &player_;
+}
+
+// -------------------------------------------------------------------
+
+// RecentPlayersRemovedNotification
+
+// repeated .bgs.protocol.user_manager.v1.RecentPlayer player = 1;
+inline int RecentPlayersRemovedNotification::player_size() const {
+  return player_.size();
+}
+inline void RecentPlayersRemovedNotification::clear_player() {
+  player_.Clear();
+}
+inline const ::bgs::protocol::user_manager::v1::RecentPlayer& RecentPlayersRemovedNotification::player(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification.player)
+  return player_.Get(index);
+}
+inline ::bgs::protocol::user_manager::v1::RecentPlayer* RecentPlayersRemovedNotification::mutable_player(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification.player)
+  return player_.Mutable(index);
+}
+inline ::bgs::protocol::user_manager::v1::RecentPlayer* RecentPlayersRemovedNotification::add_player() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification.player)
+  return player_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >&
+RecentPlayersRemovedNotification::player() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification.player)
+  return player_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::user_manager::v1::RecentPlayer >*
+RecentPlayersRemovedNotification::mutable_player() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.RecentPlayersRemovedNotification.player)
+  return &player_;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace user_manager
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_user_5fmanager_5fservice_2eproto__INCLUDED
diff --git a/src/server/proto/Client/user_manager_types.pb.cc b/src/server/proto/Client/user_manager_types.pb.cc
new file mode 100644
index 00000000000..c296b09230f
--- /dev/null
+++ b/src/server/proto/Client/user_manager_types.pb.cc
@@ -0,0 +1,1009 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: user_manager_types.proto
+
+#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
+#include "user_manager_types.pb.h"
+
+#include <algorithm>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+#include "Log.h"
+// @@protoc_insertion_point(includes)
+
+// Fix stupid windows.h included from Log.h->Common.h
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+namespace bgs {
+namespace protocol {
+namespace user_manager {
+namespace v1 {
+
+namespace {
+
+const ::google::protobuf::Descriptor* RecentPlayer_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  RecentPlayer_reflection_ = NULL;
+const ::google::protobuf::Descriptor* BlockedPlayer_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  BlockedPlayer_reflection_ = NULL;
+
+}  // namespace
+
+
+void protobuf_AssignDesc_user_5fmanager_5ftypes_2eproto() {
+  protobuf_AddDesc_user_5fmanager_5ftypes_2eproto();
+  const ::google::protobuf::FileDescriptor* file =
+    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
+      "user_manager_types.proto");
+  GOOGLE_CHECK(file != NULL);
+  RecentPlayer_descriptor_ = file->message_type(0);
+  static const int RecentPlayer_offsets_[6] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayer, entity_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayer, program_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayer, timestamp_played_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayer, attributes_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayer, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayer, counter_),
+  };
+  RecentPlayer_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      RecentPlayer_descriptor_,
+      RecentPlayer::default_instance_,
+      RecentPlayer_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayer, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(RecentPlayer, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(RecentPlayer));
+  BlockedPlayer_descriptor_ = file->message_type(1);
+  static const int BlockedPlayer_offsets_[4] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayer, account_id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayer, name_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayer, role_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayer, privileges_),
+  };
+  BlockedPlayer_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      BlockedPlayer_descriptor_,
+      BlockedPlayer::default_instance_,
+      BlockedPlayer_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayer, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(BlockedPlayer, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(BlockedPlayer));
+}
+
+namespace {
+
+GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
+inline void protobuf_AssignDescriptorsOnce() {
+  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
+                 &protobuf_AssignDesc_user_5fmanager_5ftypes_2eproto);
+}
+
+void protobuf_RegisterTypes(const ::std::string&) {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    RecentPlayer_descriptor_, &RecentPlayer::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    BlockedPlayer_descriptor_, &BlockedPlayer::default_instance());
+}
+
+}  // namespace
+
+void protobuf_ShutdownFile_user_5fmanager_5ftypes_2eproto() {
+  delete RecentPlayer::default_instance_;
+  delete RecentPlayer_reflection_;
+  delete BlockedPlayer::default_instance_;
+  delete BlockedPlayer_reflection_;
+}
+
+void protobuf_AddDesc_user_5fmanager_5ftypes_2eproto() {
+  static bool already_here = false;
+  if (already_here) return;
+  already_here = true;
+  GOOGLE_PROTOBUF_VERIFY_VERSION;
+
+  ::bgs::protocol::protobuf_AddDesc_entity_5ftypes_2eproto();
+  ::bgs::protocol::protobuf_AddDesc_attribute_5ftypes_2eproto();
+  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
+    "\n\030user_manager_types.proto\022\034bgs.protocol"
+    ".user_manager.v1\032\022entity_types.proto\032\025at"
+    "tribute_types.proto\"\264\001\n\014RecentPlayer\022)\n\t"
+    "entity_id\030\001 \002(\0132\026.bgs.protocol.EntityId\022"
+    "\017\n\007program\030\002 \001(\t\022\030\n\020timestamp_played\030\003 \001"
+    "(\006\022+\n\nattributes\030\004 \003(\0132\027.bgs.protocol.At"
+    "tribute\022\r\n\002id\030\005 \001(\007:\0010\022\022\n\007counter\030\006 \001(\007:"
+    "\0010\"r\n\rBlockedPlayer\022*\n\naccount_id\030\001 \002(\0132"
+    "\026.bgs.protocol.EntityId\022\014\n\004name\030\002 \001(\t\022\020\n"
+    "\004role\030\003 \003(\rB\002\020\001\022\025\n\nprivileges\030\004 \001(\004:\0010B\002"
+    "H\001", 402);
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
+    "user_manager_types.proto", &protobuf_RegisterTypes);
+  RecentPlayer::default_instance_ = new RecentPlayer();
+  BlockedPlayer::default_instance_ = new BlockedPlayer();
+  RecentPlayer::default_instance_->InitAsDefaultInstance();
+  BlockedPlayer::default_instance_->InitAsDefaultInstance();
+  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_user_5fmanager_5ftypes_2eproto);
+}
+
+// Force AddDescriptors() to be called at static initialization time.
+struct StaticDescriptorInitializer_user_5fmanager_5ftypes_2eproto {
+  StaticDescriptorInitializer_user_5fmanager_5ftypes_2eproto() {
+    protobuf_AddDesc_user_5fmanager_5ftypes_2eproto();
+  }
+} static_descriptor_initializer_user_5fmanager_5ftypes_2eproto_;
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int RecentPlayer::kEntityIdFieldNumber;
+const int RecentPlayer::kProgramFieldNumber;
+const int RecentPlayer::kTimestampPlayedFieldNumber;
+const int RecentPlayer::kAttributesFieldNumber;
+const int RecentPlayer::kIdFieldNumber;
+const int RecentPlayer::kCounterFieldNumber;
+#endif  // !_MSC_VER
+
+RecentPlayer::RecentPlayer()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.RecentPlayer)
+}
+
+void RecentPlayer::InitAsDefaultInstance() {
+  entity_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+RecentPlayer::RecentPlayer(const RecentPlayer& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.RecentPlayer)
+}
+
+void RecentPlayer::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  entity_id_ = NULL;
+  program_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  timestamp_played_ = GOOGLE_ULONGLONG(0);
+  id_ = 0u;
+  counter_ = 0u;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+RecentPlayer::~RecentPlayer() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.RecentPlayer)
+  SharedDtor();
+}
+
+void RecentPlayer::SharedDtor() {
+  if (program_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete program_;
+  }
+  if (this != default_instance_) {
+    delete entity_id_;
+  }
+}
+
+void RecentPlayer::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* RecentPlayer::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return RecentPlayer_descriptor_;
+}
+
+const RecentPlayer& RecentPlayer::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+RecentPlayer* RecentPlayer::default_instance_ = NULL;
+
+RecentPlayer* RecentPlayer::New() const {
+  return new RecentPlayer;
+}
+
+void RecentPlayer::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<RecentPlayer*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 55) {
+    ZR_(id_, counter_);
+    if (has_entity_id()) {
+      if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_program()) {
+      if (program_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        program_->clear();
+      }
+    }
+    timestamp_played_ = GOOGLE_ULONGLONG(0);
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  attributes_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool RecentPlayer::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.RecentPlayer)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.EntityId entity_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_entity_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_program;
+        break;
+      }
+
+      // optional string program = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_program:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_program()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->program().data(), this->program().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "program");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(25)) goto parse_timestamp_played;
+        break;
+      }
+
+      // optional fixed64 timestamp_played = 3;
+      case 3: {
+        if (tag == 25) {
+         parse_timestamp_played:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED64>(
+                 input, &timestamp_played_)));
+          set_has_timestamp_played();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_attributes;
+        break;
+      }
+
+      // repeated .bgs.protocol.Attribute attributes = 4;
+      case 4: {
+        if (tag == 34) {
+         parse_attributes:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+                input, add_attributes()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(34)) goto parse_attributes;
+        if (input->ExpectTag(45)) goto parse_id;
+        break;
+      }
+
+      // optional fixed32 id = 5 [default = 0];
+      case 5: {
+        if (tag == 45) {
+         parse_id:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(53)) goto parse_counter;
+        break;
+      }
+
+      // optional fixed32 counter = 6 [default = 0];
+      case 6: {
+        if (tag == 53) {
+         parse_counter:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_FIXED32>(
+                 input, &counter_)));
+          set_has_counter();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.RecentPlayer)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.RecentPlayer)
+  return false;
+#undef DO_
+}
+
+void RecentPlayer::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.RecentPlayer)
+  // required .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->entity_id(), output);
+  }
+
+  // optional string program = 2;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->program().data(), this->program().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "program");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->program(), output);
+  }
+
+  // optional fixed64 timestamp_played = 3;
+  if (has_timestamp_played()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed64(3, this->timestamp_played(), output);
+  }
+
+  // repeated .bgs.protocol.Attribute attributes = 4;
+  for (int i = 0; i < this->attributes_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      4, this->attributes(i), output);
+  }
+
+  // optional fixed32 id = 5 [default = 0];
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(5, this->id(), output);
+  }
+
+  // optional fixed32 counter = 6 [default = 0];
+  if (has_counter()) {
+    ::google::protobuf::internal::WireFormatLite::WriteFixed32(6, this->counter(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.RecentPlayer)
+}
+
+::google::protobuf::uint8* RecentPlayer::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.RecentPlayer)
+  // required .bgs.protocol.EntityId entity_id = 1;
+  if (has_entity_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->entity_id(), target);
+  }
+
+  // optional string program = 2;
+  if (has_program()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->program().data(), this->program().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "program");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->program(), target);
+  }
+
+  // optional fixed64 timestamp_played = 3;
+  if (has_timestamp_played()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed64ToArray(3, this->timestamp_played(), target);
+  }
+
+  // repeated .bgs.protocol.Attribute attributes = 4;
+  for (int i = 0; i < this->attributes_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        4, this->attributes(i), target);
+  }
+
+  // optional fixed32 id = 5 [default = 0];
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(5, this->id(), target);
+  }
+
+  // optional fixed32 counter = 6 [default = 0];
+  if (has_counter()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteFixed32ToArray(6, this->counter(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.RecentPlayer)
+  return target;
+}
+
+int RecentPlayer::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.EntityId entity_id = 1;
+    if (has_entity_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->entity_id());
+    }
+
+    // optional string program = 2;
+    if (has_program()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->program());
+    }
+
+    // optional fixed64 timestamp_played = 3;
+    if (has_timestamp_played()) {
+      total_size += 1 + 8;
+    }
+
+    // optional fixed32 id = 5 [default = 0];
+    if (has_id()) {
+      total_size += 1 + 4;
+    }
+
+    // optional fixed32 counter = 6 [default = 0];
+    if (has_counter()) {
+      total_size += 1 + 4;
+    }
+
+  }
+  // repeated .bgs.protocol.Attribute attributes = 4;
+  total_size += 1 * this->attributes_size();
+  for (int i = 0; i < this->attributes_size(); i++) {
+    total_size +=
+      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+        this->attributes(i));
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void RecentPlayer::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const RecentPlayer* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const RecentPlayer*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void RecentPlayer::MergeFrom(const RecentPlayer& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  attributes_.MergeFrom(from.attributes_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_entity_id()) {
+      mutable_entity_id()->::bgs::protocol::EntityId::MergeFrom(from.entity_id());
+    }
+    if (from.has_program()) {
+      set_program(from.program());
+    }
+    if (from.has_timestamp_played()) {
+      set_timestamp_played(from.timestamp_played());
+    }
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_counter()) {
+      set_counter(from.counter());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void RecentPlayer::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void RecentPlayer::CopyFrom(const RecentPlayer& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool RecentPlayer::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_entity_id()) {
+    if (!this->entity_id().IsInitialized()) return false;
+  }
+  if (!::google::protobuf::internal::AllAreInitialized(this->attributes())) return false;
+  return true;
+}
+
+void RecentPlayer::Swap(RecentPlayer* other) {
+  if (other != this) {
+    std::swap(entity_id_, other->entity_id_);
+    std::swap(program_, other->program_);
+    std::swap(timestamp_played_, other->timestamp_played_);
+    attributes_.Swap(&other->attributes_);
+    std::swap(id_, other->id_);
+    std::swap(counter_, other->counter_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata RecentPlayer::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = RecentPlayer_descriptor_;
+  metadata.reflection = RecentPlayer_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
+const int BlockedPlayer::kAccountIdFieldNumber;
+const int BlockedPlayer::kNameFieldNumber;
+const int BlockedPlayer::kRoleFieldNumber;
+const int BlockedPlayer::kPrivilegesFieldNumber;
+#endif  // !_MSC_VER
+
+BlockedPlayer::BlockedPlayer()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:bgs.protocol.user_manager.v1.BlockedPlayer)
+}
+
+void BlockedPlayer::InitAsDefaultInstance() {
+  account_id_ = const_cast< ::bgs::protocol::EntityId*>(&::bgs::protocol::EntityId::default_instance());
+}
+
+BlockedPlayer::BlockedPlayer(const BlockedPlayer& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:bgs.protocol.user_manager.v1.BlockedPlayer)
+}
+
+void BlockedPlayer::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  account_id_ = NULL;
+  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  privileges_ = GOOGLE_ULONGLONG(0);
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+BlockedPlayer::~BlockedPlayer() {
+  // @@protoc_insertion_point(destructor:bgs.protocol.user_manager.v1.BlockedPlayer)
+  SharedDtor();
+}
+
+void BlockedPlayer::SharedDtor() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (this != default_instance_) {
+    delete account_id_;
+  }
+}
+
+void BlockedPlayer::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* BlockedPlayer::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return BlockedPlayer_descriptor_;
+}
+
+const BlockedPlayer& BlockedPlayer::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_user_5fmanager_5ftypes_2eproto();
+  return *default_instance_;
+}
+
+BlockedPlayer* BlockedPlayer::default_instance_ = NULL;
+
+BlockedPlayer* BlockedPlayer::New() const {
+  return new BlockedPlayer;
+}
+
+void BlockedPlayer::Clear() {
+  if (_has_bits_[0 / 32] & 11) {
+    if (has_account_id()) {
+      if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+    }
+    if (has_name()) {
+      if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        name_->clear();
+      }
+    }
+    privileges_ = GOOGLE_ULONGLONG(0);
+  }
+  role_.Clear();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool BlockedPlayer::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:bgs.protocol.user_manager.v1.BlockedPlayer)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // required .bgs.protocol.EntityId account_id = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_account_id()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_name;
+        break;
+      }
+
+      // optional string name = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_name:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
+                input, this->mutable_name()));
+          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+            this->name().data(), this->name().length(),
+            ::google::protobuf::internal::WireFormat::PARSE,
+            "name");
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(26)) goto parse_role;
+        break;
+      }
+
+      // repeated uint32 role = 3 [packed = true];
+      case 3: {
+        if (tag == 26) {
+         parse_role:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, this->mutable_role())));
+        } else if (tag == 24) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitiveNoInline<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 1, 26, input, this->mutable_role())));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_privileges;
+        break;
+      }
+
+      // optional uint64 privileges = 4 [default = 0];
+      case 4: {
+        if (tag == 32) {
+         parse_privileges:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &privileges_)));
+          set_has_privileges();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:bgs.protocol.user_manager.v1.BlockedPlayer)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:bgs.protocol.user_manager.v1.BlockedPlayer)
+  return false;
+#undef DO_
+}
+
+void BlockedPlayer::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:bgs.protocol.user_manager.v1.BlockedPlayer)
+  // required .bgs.protocol.EntityId account_id = 1;
+  if (has_account_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->account_id(), output);
+  }
+
+  // optional string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
+      2, this->name(), output);
+  }
+
+  // repeated uint32 role = 3 [packed = true];
+  if (this->role_size() > 0) {
+    ::google::protobuf::internal::WireFormatLite::WriteTag(3, ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED, output);
+    output->WriteVarint32(_role_cached_byte_size_);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32NoTag(
+      this->role(i), output);
+  }
+
+  // optional uint64 privileges = 4 [default = 0];
+  if (has_privileges()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->privileges(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:bgs.protocol.user_manager.v1.BlockedPlayer)
+}
+
+::google::protobuf::uint8* BlockedPlayer::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:bgs.protocol.user_manager.v1.BlockedPlayer)
+  // required .bgs.protocol.EntityId account_id = 1;
+  if (has_account_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->account_id(), target);
+  }
+
+  // optional string name = 2;
+  if (has_name()) {
+    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
+      this->name().data(), this->name().length(),
+      ::google::protobuf::internal::WireFormat::SERIALIZE,
+      "name");
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
+        2, this->name(), target);
+  }
+
+  // repeated uint32 role = 3 [packed = true];
+  if (this->role_size() > 0) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteTagToArray(
+      3,
+      ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+      target);
+    target = ::google::protobuf::io::CodedOutputStream::WriteVarint32ToArray(
+      _role_cached_byte_size_, target);
+  }
+  for (int i = 0; i < this->role_size(); i++) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteUInt32NoTagToArray(this->role(i), target);
+  }
+
+  // optional uint64 privileges = 4 [default = 0];
+  if (has_privileges()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->privileges(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:bgs.protocol.user_manager.v1.BlockedPlayer)
+  return target;
+}
+
+int BlockedPlayer::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // required .bgs.protocol.EntityId account_id = 1;
+    if (has_account_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->account_id());
+    }
+
+    // optional string name = 2;
+    if (has_name()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::StringSize(
+          this->name());
+    }
+
+    // optional uint64 privileges = 4 [default = 0];
+    if (has_privileges()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->privileges());
+    }
+
+  }
+  // repeated uint32 role = 3 [packed = true];
+  {
+    int data_size = 0;
+    for (int i = 0; i < this->role_size(); i++) {
+      data_size += ::google::protobuf::internal::WireFormatLite::
+        UInt32Size(this->role(i));
+    }
+    if (data_size > 0) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::Int32Size(data_size);
+    }
+    GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+    _role_cached_byte_size_ = data_size;
+    GOOGLE_SAFE_CONCURRENT_WRITES_END();
+    total_size += data_size;
+  }
+
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void BlockedPlayer::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const BlockedPlayer* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const BlockedPlayer*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void BlockedPlayer::MergeFrom(const BlockedPlayer& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  role_.MergeFrom(from.role_);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_account_id()) {
+      mutable_account_id()->::bgs::protocol::EntityId::MergeFrom(from.account_id());
+    }
+    if (from.has_name()) {
+      set_name(from.name());
+    }
+    if (from.has_privileges()) {
+      set_privileges(from.privileges());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void BlockedPlayer::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void BlockedPlayer::CopyFrom(const BlockedPlayer& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool BlockedPlayer::IsInitialized() const {
+  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
+
+  if (has_account_id()) {
+    if (!this->account_id().IsInitialized()) return false;
+  }
+  return true;
+}
+
+void BlockedPlayer::Swap(BlockedPlayer* other) {
+  if (other != this) {
+    std::swap(account_id_, other->account_id_);
+    std::swap(name_, other->name_);
+    role_.Swap(&other->role_);
+    std::swap(privileges_, other->privileges_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata BlockedPlayer::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = BlockedPlayer_descriptor_;
+  metadata.reflection = BlockedPlayer_reflection_;
+  return metadata;
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace user_manager
+}  // namespace protocol
+}  // namespace bgs
+
+// @@protoc_insertion_point(global_scope)
diff --git a/src/server/proto/Client/user_manager_types.pb.h b/src/server/proto/Client/user_manager_types.pb.h
new file mode 100644
index 00000000000..93b4a04e802
--- /dev/null
+++ b/src/server/proto/Client/user_manager_types.pb.h
@@ -0,0 +1,727 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: user_manager_types.proto
+
+#ifndef PROTOBUF_user_5fmanager_5ftypes_2eproto__INCLUDED
+#define PROTOBUF_user_5fmanager_5ftypes_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 "entity_types.pb.h"
+#include "attribute_types.pb.h"
+#include "Define.h" // for TRINITY_SHARED_API
+// @@protoc_insertion_point(includes)
+
+namespace bgs {
+namespace protocol {
+namespace user_manager {
+namespace v1 {
+
+// Internal implementation detail -- do not call these.
+void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5ftypes_2eproto();
+void protobuf_AssignDesc_user_5fmanager_5ftypes_2eproto();
+void protobuf_ShutdownFile_user_5fmanager_5ftypes_2eproto();
+
+class RecentPlayer;
+class BlockedPlayer;
+
+// ===================================================================
+
+class TC_SHARED_API RecentPlayer : public ::google::protobuf::Message {
+ public:
+  RecentPlayer();
+  virtual ~RecentPlayer();
+
+  RecentPlayer(const RecentPlayer& from);
+
+  inline RecentPlayer& operator=(const RecentPlayer& 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 RecentPlayer& default_instance();
+
+  void Swap(RecentPlayer* other);
+
+  // implements Message ----------------------------------------------
+
+  RecentPlayer* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const RecentPlayer& from);
+  void MergeFrom(const RecentPlayer& 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 entity_id = 1;
+  inline bool has_entity_id() const;
+  inline void clear_entity_id();
+  static const int kEntityIdFieldNumber = 1;
+  inline const ::bgs::protocol::EntityId& entity_id() const;
+  inline ::bgs::protocol::EntityId* mutable_entity_id();
+  inline ::bgs::protocol::EntityId* release_entity_id();
+  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
+
+  // optional string program = 2;
+  inline bool has_program() const;
+  inline void clear_program();
+  static const int kProgramFieldNumber = 2;
+  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 fixed64 timestamp_played = 3;
+  inline bool has_timestamp_played() const;
+  inline void clear_timestamp_played();
+  static const int kTimestampPlayedFieldNumber = 3;
+  inline ::google::protobuf::uint64 timestamp_played() const;
+  inline void set_timestamp_played(::google::protobuf::uint64 value);
+
+  // repeated .bgs.protocol.Attribute attributes = 4;
+  inline int attributes_size() const;
+  inline void clear_attributes();
+  static const int kAttributesFieldNumber = 4;
+  inline const ::bgs::protocol::Attribute& attributes(int index) const;
+  inline ::bgs::protocol::Attribute* mutable_attributes(int index);
+  inline ::bgs::protocol::Attribute* add_attributes();
+  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+      attributes() const;
+  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+      mutable_attributes();
+
+  // optional fixed32 id = 5 [default = 0];
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 5;
+  inline ::google::protobuf::uint32 id() const;
+  inline void set_id(::google::protobuf::uint32 value);
+
+  // optional fixed32 counter = 6 [default = 0];
+  inline bool has_counter() const;
+  inline void clear_counter();
+  static const int kCounterFieldNumber = 6;
+  inline ::google::protobuf::uint32 counter() const;
+  inline void set_counter(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.RecentPlayer)
+ private:
+  inline void set_has_entity_id();
+  inline void clear_has_entity_id();
+  inline void set_has_program();
+  inline void clear_has_program();
+  inline void set_has_timestamp_played();
+  inline void clear_has_timestamp_played();
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_counter();
+  inline void clear_has_counter();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* entity_id_;
+  ::std::string* program_;
+  ::google::protobuf::uint64 timestamp_played_;
+  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attributes_;
+  ::google::protobuf::uint32 id_;
+  ::google::protobuf::uint32 counter_;
+  friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_user_5fmanager_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_user_5fmanager_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static RecentPlayer* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class TC_SHARED_API BlockedPlayer : public ::google::protobuf::Message {
+ public:
+  BlockedPlayer();
+  virtual ~BlockedPlayer();
+
+  BlockedPlayer(const BlockedPlayer& from);
+
+  inline BlockedPlayer& operator=(const BlockedPlayer& 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 BlockedPlayer& default_instance();
+
+  void Swap(BlockedPlayer* other);
+
+  // implements Message ----------------------------------------------
+
+  BlockedPlayer* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const BlockedPlayer& from);
+  void MergeFrom(const BlockedPlayer& 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 account_id = 1;
+  inline bool has_account_id() const;
+  inline void clear_account_id();
+  static const int kAccountIdFieldNumber = 1;
+  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);
+
+  // optional string name = 2;
+  inline bool has_name() const;
+  inline void clear_name();
+  static const int kNameFieldNumber = 2;
+  inline const ::std::string& name() const;
+  inline void set_name(const ::std::string& value);
+  inline void set_name(const char* value);
+  inline void set_name(const char* value, size_t size);
+  inline ::std::string* mutable_name();
+  inline ::std::string* release_name();
+  inline void set_allocated_name(::std::string* name);
+
+  // repeated uint32 role = 3 [packed = true];
+  inline int role_size() const;
+  inline void clear_role();
+  static const int kRoleFieldNumber = 3;
+  inline ::google::protobuf::uint32 role(int index) const;
+  inline void set_role(int index, ::google::protobuf::uint32 value);
+  inline void add_role(::google::protobuf::uint32 value);
+  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      role() const;
+  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_role();
+
+  // optional uint64 privileges = 4 [default = 0];
+  inline bool has_privileges() const;
+  inline void clear_privileges();
+  static const int kPrivilegesFieldNumber = 4;
+  inline ::google::protobuf::uint64 privileges() const;
+  inline void set_privileges(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:bgs.protocol.user_manager.v1.BlockedPlayer)
+ private:
+  inline void set_has_account_id();
+  inline void clear_has_account_id();
+  inline void set_has_name();
+  inline void clear_has_name();
+  inline void set_has_privileges();
+  inline void clear_has_privileges();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::bgs::protocol::EntityId* account_id_;
+  ::std::string* name_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
+  mutable int _role_cached_byte_size_;
+  ::google::protobuf::uint64 privileges_;
+  friend void TC_SHARED_API protobuf_AddDesc_user_5fmanager_5ftypes_2eproto();
+  friend void protobuf_AssignDesc_user_5fmanager_5ftypes_2eproto();
+  friend void protobuf_ShutdownFile_user_5fmanager_5ftypes_2eproto();
+
+  void InitAsDefaultInstance();
+  static BlockedPlayer* default_instance_;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+// RecentPlayer
+
+// required .bgs.protocol.EntityId entity_id = 1;
+inline bool RecentPlayer::has_entity_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void RecentPlayer::set_has_entity_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void RecentPlayer::clear_has_entity_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void RecentPlayer::clear_entity_id() {
+  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_entity_id();
+}
+inline const ::bgs::protocol::EntityId& RecentPlayer::entity_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.RecentPlayer.entity_id)
+  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
+}
+inline ::bgs::protocol::EntityId* RecentPlayer::mutable_entity_id() {
+  set_has_entity_id();
+  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.RecentPlayer.entity_id)
+  return entity_id_;
+}
+inline ::bgs::protocol::EntityId* RecentPlayer::release_entity_id() {
+  clear_has_entity_id();
+  ::bgs::protocol::EntityId* temp = entity_id_;
+  entity_id_ = NULL;
+  return temp;
+}
+inline void RecentPlayer::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
+  delete entity_id_;
+  entity_id_ = entity_id;
+  if (entity_id) {
+    set_has_entity_id();
+  } else {
+    clear_has_entity_id();
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.RecentPlayer.entity_id)
+}
+
+// optional string program = 2;
+inline bool RecentPlayer::has_program() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void RecentPlayer::set_has_program() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void RecentPlayer::clear_has_program() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void RecentPlayer::clear_program() {
+  if (program_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    program_->clear();
+  }
+  clear_has_program();
+}
+inline const ::std::string& RecentPlayer::program() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.RecentPlayer.program)
+  return *program_;
+}
+inline void RecentPlayer::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.user_manager.v1.RecentPlayer.program)
+}
+inline void RecentPlayer::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.user_manager.v1.RecentPlayer.program)
+}
+inline void RecentPlayer::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.user_manager.v1.RecentPlayer.program)
+}
+inline ::std::string* RecentPlayer::mutable_program() {
+  set_has_program();
+  if (program_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    program_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.RecentPlayer.program)
+  return program_;
+}
+inline ::std::string* RecentPlayer::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 RecentPlayer::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.user_manager.v1.RecentPlayer.program)
+}
+
+// optional fixed64 timestamp_played = 3;
+inline bool RecentPlayer::has_timestamp_played() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void RecentPlayer::set_has_timestamp_played() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void RecentPlayer::clear_has_timestamp_played() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void RecentPlayer::clear_timestamp_played() {
+  timestamp_played_ = GOOGLE_ULONGLONG(0);
+  clear_has_timestamp_played();
+}
+inline ::google::protobuf::uint64 RecentPlayer::timestamp_played() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.RecentPlayer.timestamp_played)
+  return timestamp_played_;
+}
+inline void RecentPlayer::set_timestamp_played(::google::protobuf::uint64 value) {
+  set_has_timestamp_played();
+  timestamp_played_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.RecentPlayer.timestamp_played)
+}
+
+// repeated .bgs.protocol.Attribute attributes = 4;
+inline int RecentPlayer::attributes_size() const {
+  return attributes_.size();
+}
+inline void RecentPlayer::clear_attributes() {
+  attributes_.Clear();
+}
+inline const ::bgs::protocol::Attribute& RecentPlayer::attributes(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.RecentPlayer.attributes)
+  return attributes_.Get(index);
+}
+inline ::bgs::protocol::Attribute* RecentPlayer::mutable_attributes(int index) {
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.RecentPlayer.attributes)
+  return attributes_.Mutable(index);
+}
+inline ::bgs::protocol::Attribute* RecentPlayer::add_attributes() {
+  // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.RecentPlayer.attributes)
+  return attributes_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
+RecentPlayer::attributes() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.RecentPlayer.attributes)
+  return attributes_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
+RecentPlayer::mutable_attributes() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.RecentPlayer.attributes)
+  return &attributes_;
+}
+
+// optional fixed32 id = 5 [default = 0];
+inline bool RecentPlayer::has_id() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void RecentPlayer::set_has_id() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void RecentPlayer::clear_has_id() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void RecentPlayer::clear_id() {
+  id_ = 0u;
+  clear_has_id();
+}
+inline ::google::protobuf::uint32 RecentPlayer::id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.RecentPlayer.id)
+  return id_;
+}
+inline void RecentPlayer::set_id(::google::protobuf::uint32 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.RecentPlayer.id)
+}
+
+// optional fixed32 counter = 6 [default = 0];
+inline bool RecentPlayer::has_counter() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void RecentPlayer::set_has_counter() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void RecentPlayer::clear_has_counter() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void RecentPlayer::clear_counter() {
+  counter_ = 0u;
+  clear_has_counter();
+}
+inline ::google::protobuf::uint32 RecentPlayer::counter() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.RecentPlayer.counter)
+  return counter_;
+}
+inline void RecentPlayer::set_counter(::google::protobuf::uint32 value) {
+  set_has_counter();
+  counter_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.RecentPlayer.counter)
+}
+
+// -------------------------------------------------------------------
+
+// BlockedPlayer
+
+// required .bgs.protocol.EntityId account_id = 1;
+inline bool BlockedPlayer::has_account_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void BlockedPlayer::set_has_account_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void BlockedPlayer::clear_has_account_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void BlockedPlayer::clear_account_id() {
+  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
+  clear_has_account_id();
+}
+inline const ::bgs::protocol::EntityId& BlockedPlayer::account_id() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayer.account_id)
+  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
+}
+inline ::bgs::protocol::EntityId* BlockedPlayer::mutable_account_id() {
+  set_has_account_id();
+  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockedPlayer.account_id)
+  return account_id_;
+}
+inline ::bgs::protocol::EntityId* BlockedPlayer::release_account_id() {
+  clear_has_account_id();
+  ::bgs::protocol::EntityId* temp = account_id_;
+  account_id_ = NULL;
+  return temp;
+}
+inline void BlockedPlayer::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.user_manager.v1.BlockedPlayer.account_id)
+}
+
+// optional string name = 2;
+inline bool BlockedPlayer::has_name() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void BlockedPlayer::set_has_name() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void BlockedPlayer::clear_has_name() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void BlockedPlayer::clear_name() {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_->clear();
+  }
+  clear_has_name();
+}
+inline const ::std::string& BlockedPlayer::name() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayer.name)
+  return *name_;
+}
+inline void BlockedPlayer::set_name(const ::std::string& value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.BlockedPlayer.name)
+}
+inline void BlockedPlayer::set_name(const char* value) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(value);
+  // @@protoc_insertion_point(field_set_char:bgs.protocol.user_manager.v1.BlockedPlayer.name)
+}
+inline void BlockedPlayer::set_name(const char* value, size_t size) {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  name_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.user_manager.v1.BlockedPlayer.name)
+}
+inline ::std::string* BlockedPlayer::mutable_name() {
+  set_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    name_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:bgs.protocol.user_manager.v1.BlockedPlayer.name)
+  return name_;
+}
+inline ::std::string* BlockedPlayer::release_name() {
+  clear_has_name();
+  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = name_;
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void BlockedPlayer::set_allocated_name(::std::string* name) {
+  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete name_;
+  }
+  if (name) {
+    set_has_name();
+    name_ = name;
+  } else {
+    clear_has_name();
+    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.user_manager.v1.BlockedPlayer.name)
+}
+
+// repeated uint32 role = 3 [packed = true];
+inline int BlockedPlayer::role_size() const {
+  return role_.size();
+}
+inline void BlockedPlayer::clear_role() {
+  role_.Clear();
+}
+inline ::google::protobuf::uint32 BlockedPlayer::role(int index) const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayer.role)
+  return role_.Get(index);
+}
+inline void BlockedPlayer::set_role(int index, ::google::protobuf::uint32 value) {
+  role_.Set(index, value);
+  // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.BlockedPlayer.role)
+}
+inline void BlockedPlayer::add_role(::google::protobuf::uint32 value) {
+  role_.Add(value);
+  // @@protoc_insertion_point(field_add:bgs.protocol.user_manager.v1.BlockedPlayer.role)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+BlockedPlayer::role() const {
+  // @@protoc_insertion_point(field_list:bgs.protocol.user_manager.v1.BlockedPlayer.role)
+  return role_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+BlockedPlayer::mutable_role() {
+  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.user_manager.v1.BlockedPlayer.role)
+  return &role_;
+}
+
+// optional uint64 privileges = 4 [default = 0];
+inline bool BlockedPlayer::has_privileges() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void BlockedPlayer::set_has_privileges() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void BlockedPlayer::clear_has_privileges() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void BlockedPlayer::clear_privileges() {
+  privileges_ = GOOGLE_ULONGLONG(0);
+  clear_has_privileges();
+}
+inline ::google::protobuf::uint64 BlockedPlayer::privileges() const {
+  // @@protoc_insertion_point(field_get:bgs.protocol.user_manager.v1.BlockedPlayer.privileges)
+  return privileges_;
+}
+inline void BlockedPlayer::set_privileges(::google::protobuf::uint64 value) {
+  set_has_privileges();
+  privileges_ = value;
+  // @@protoc_insertion_point(field_set:bgs.protocol.user_manager.v1.BlockedPlayer.privileges)
+}
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace v1
+}  // namespace user_manager
+}  // namespace protocol
+}  // namespace bgs
+
+#ifndef SWIG
+namespace google {
+namespace protobuf {
+
+
+}  // namespace google
+}  // namespace protobuf
+#endif  // SWIG
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_user_5fmanager_5ftypes_2eproto__INCLUDED
diff --git a/src/server/proto/PrecompiledHeaders/protoPCH.cpp b/src/server/proto/PrecompiledHeaders/protoPCH.cpp
new file mode 100644
index 00000000000..ca1e45a3644
--- /dev/null
+++ b/src/server/proto/PrecompiledHeaders/protoPCH.cpp
@@ -0,0 +1 @@
+#include "protoPCH.h"
diff --git a/src/server/proto/PrecompiledHeaders/protoPCH.h b/src/server/proto/PrecompiledHeaders/protoPCH.h
new file mode 100644
index 00000000000..441e8738b5d
--- /dev/null
+++ b/src/server/proto/PrecompiledHeaders/protoPCH.h
@@ -0,0 +1,13 @@
+#include "account_service.pb.h"
+#include "authentication_service.pb.h"
+#include "challenge_service.pb.h"
+#include "channel_service.pb.h"
+#include "connection_service.pb.h"
+#include "friends_service.pb.h"
+#include "game_utilities_service.pb.h"
+#include "notification_types.pb.h"
+#include "presence_service.pb.h"
+#include "profanity_filter_config.pb.h"
+#include "report_service.pb.h"
+#include "resource_service.pb.h"
+#include "user_manager_service.pb.h"
diff --git a/src/server/proto/ServiceBase.h b/src/server/proto/ServiceBase.h
new file mode 100644
index 00000000000..9e941fcf618
--- /dev/null
+++ b/src/server/proto/ServiceBase.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef ServiceBase_h__
+#define ServiceBase_h__
+
+#include "MessageBuffer.h"
+#include "Define.h"
+#include <functional>
+#include <string>
+
+namespace google
+{
+    namespace protobuf
+    {
+        class Message;
+    }
+}
+
+class TC_SHARED_API ServiceBase
+{
+public:
+    virtual ~ServiceBase() { }
+
+    virtual void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) = 0;
+
+protected:
+    virtual void SendRequest(uint32 serviceHash, uint32 methodId, google::protobuf::Message const* request, std::function<void(MessageBuffer)> callback) = 0;
+    virtual void SendRequest(uint32 serviceHash, uint32 methodId, google::protobuf::Message const* request) = 0;
+    virtual void SendResponse(uint32 serviceHash, uint32 methodId, uint32 token, uint32 status) = 0;
+    virtual void SendResponse(uint32 serviceHash, uint32 methodId, uint32 token, google::protobuf::Message const* response) = 0;
+    virtual std::string GetCallerInfo() const = 0;
+};
+
+#endif // ServiceBase_h__
diff --git a/src/server/shared/CMakeLists.txt b/src/server/shared/CMakeLists.txt
index ce6c13bd932..052902de9c8 100644
--- a/src/server/shared/CMakeLists.txt
+++ b/src/server/shared/CMakeLists.txt
@@ -43,7 +43,8 @@ target_include_directories(shared
 target_link_libraries(shared
   PUBLIC
     database
-    rapidjson)
+    rapidjson
+    proto)
 
 set_target_properties(shared
     PROPERTIES