account_types.pb.h

Go to the documentation of this file.

// 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 "global_extensions/message_options.pb.h"
#include "global_extensions/field_options.pb.h"
#include "Define.h" // for TC_PROTO_API
// @@protoc_insertion_point(includes)
 
namespace bgs {
namespace protocol {
namespace account {
namespace v1 {
 
// Internal implementation detail -- do not call these.
void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
void protobuf_AssignDesc_account_5ftypes_2eproto();
void protobuf_ShutdownFile_account_5ftypes_2eproto();
 
class AccountId;
class AccountLicense;
class GameAccountHandle;
class AccountReference;
class Identity;
class ProgramTag;
class RegionTag;
class AccountFieldTags;
class GameAccountFieldTags;
class AccountFieldOptions;
class GameAccountFieldOptions;
class SubscriberReference;
class OptIns;
class AccountLevelInfo;
class PrivacyInfo;
class ParentalControlInfo;
class PlayScheduleRestriction;
class GameLevelInfo;
class GameTimeInfo;
class GameTimeRemainingInfo;
class GameStatus;
class RAFInfo;
class GameSessionInfo;
class GameSessionUpdateInfo;
class GameSessionLocation;
class CAIS;
class GameAccountList;
class SecurityStatus;
class AccountState;
class AccountStateTagged;
class GameAccountState;
class GameAccountStateTagged;
class AuthorizedData;
class IgrId;
class IgrAddress;
class AccountPrivacySetting;
class AccountInfo;
class RestrictionStatus;
class AccountPlatformRestrictionInfo;
 
enum PrivacyInfo_GameInfoPrivacy {
 PrivacyInfo_GameInfoPrivacy_PRIVACY_ME = 0,
 PrivacyInfo_GameInfoPrivacy_PRIVACY_FRIENDS = 1,
 PrivacyInfo_GameInfoPrivacy_PRIVACY_EVERYONE = 2
};
TC_PROTO_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_PROTO_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_OVER_18 = 2,
 IDENT_UNDER_18 = 3,
 IDENT_FAILED = 4,
 IDENT_SUCCESS = 5,
 IDENT_SUCC_MNL = 6,
 IDENT_UNKNOWN = 7
};
TC_PROTO_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_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_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;
 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 string phone_number = 5;
 inline bool has_phone_number() const;
 inline void clear_phone_number();
 static const int kPhoneNumberFieldNumber = 5;
 inline const ::std::string& phone_number() const;
 inline void set_phone_number(const ::std::string& value);
 inline void set_phone_number(const char* value);
 inline void set_phone_number(const char* value, size_t size);
 inline ::std::string* mutable_phone_number();
 inline ::std::string* release_phone_number();
 inline void set_allocated_phone_number(::std::string* phone_number);
 
 // 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_phone_number();
 inline void clear_has_phone_number();
 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_;
 ::std::string* phone_number_;
 friend void TC_PROTO_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_PROTO_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;
 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);
 
 // @@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();
 
 ::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_;
 friend void TC_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_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;
 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();
 
 // optional fixed32 security_status_tag = 12;
 inline bool has_security_status_tag() const;
 inline void clear_security_status_tag();
 static const int kSecurityStatusTagFieldNumber = 12;
 inline ::google::protobuf::uint32 security_status_tag() const;
 inline void set_security_status_tag(::google::protobuf::uint32 value);
 
 // @@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();
 inline void set_has_security_status_tag();
 inline void clear_has_security_status_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::uint32 parental_control_info_tag_;
 ::google::protobuf::uint32 security_status_tag_;
 ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::RegionTag > game_account_tags_;
 friend void TC_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_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;
 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);
 
 // optional bool field_security_status = 9;
 inline bool has_field_security_status() const;
 inline void clear_field_security_status();
 static const int kFieldSecurityStatusFieldNumber = 9;
 inline bool field_security_status() const;
 inline void set_field_security_status(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();
 inline void set_has_field_security_status();
 inline void clear_has_field_security_status();
 
 ::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_;
 bool field_security_status_;
 friend void TC_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_API OptIns : public ::google::protobuf::Message {
 public:
 OptIns();
 virtual ~OptIns();
 
 OptIns(const OptIns& from);
 
 inline OptIns& operator=(const OptIns& 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 OptIns& default_instance();
 
 void Swap(OptIns* other);
 
 // implements Message ----------------------------------------------
 
 OptIns* New() 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 uint64 ids = 1 [packed = true];
 inline int ids_size() const;
 inline void clear_ids();
 static const int kIdsFieldNumber = 1;
 inline ::google::protobuf::uint64 ids(int index) const;
 inline void set_ids(int index, ::google::protobuf::uint64 value);
 inline void add_ids(::google::protobuf::uint64 value);
 inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
 ids() const;
 inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
 mutable_ids();
 
 // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.OptIns)
 private:
 
 ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > ids_;
 friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
 friend void protobuf_AssignDesc_account_5ftypes_2eproto();
 friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
 
 void InitAsDefaultInstance();
 static OptIns* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_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;
 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);
 
 // optional bool headless_account = 14;
 inline bool has_headless_account() const;
 inline void clear_headless_account();
 static const int kHeadlessAccountFieldNumber = 14;
 inline bool headless_account() const;
 inline void set_headless_account(bool value);
 
 // optional bool test_account = 15;
 inline bool has_test_account() const;
 inline void clear_test_account();
 static const int kTestAccountFieldNumber = 15;
 inline bool test_account() const;
 inline void set_test_account(bool value);
 
 // optional bool is_sms_protected = 17;
 inline bool has_is_sms_protected() const;
 inline void clear_is_sms_protected();
 static const int kIsSmsProtectedFieldNumber = 17;
 inline bool is_sms_protected() const;
 inline void set_is_sms_protected(bool value);
 
 // optional uint32 ratings_board_minimum_age = 18;
 inline bool has_ratings_board_minimum_age() const;
 inline void clear_ratings_board_minimum_age();
 static const int kRatingsBoardMinimumAgeFieldNumber = 18;
 inline ::google::protobuf::uint32 ratings_board_minimum_age() const;
 inline void set_ratings_board_minimum_age(::google::protobuf::uint32 value);
 
 // optional string phone_number = 19;
 inline bool has_phone_number() const;
 inline void clear_phone_number();
 static const int kPhoneNumberFieldNumber = 19;
 inline const ::std::string& phone_number() const;
 inline void set_phone_number(const ::std::string& value);
 inline void set_phone_number(const char* value);
 inline void set_phone_number(const char* value, size_t size);
 inline ::std::string* mutable_phone_number();
 inline ::std::string* release_phone_number();
 inline void set_allocated_phone_number(::std::string* phone_number);
 
 // optional string birthdate = 20;
 inline bool has_birthdate() const;
 inline void clear_birthdate();
 static const int kBirthdateFieldNumber = 20;
 inline const ::std::string& birthdate() const;
 inline void set_birthdate(const ::std::string& value);
 inline void set_birthdate(const char* value);
 inline void set_birthdate(const char* value, size_t size);
 inline ::std::string* mutable_birthdate();
 inline ::std::string* release_birthdate();
 inline void set_allocated_birthdate(::std::string* birthdate);
 
 // optional bool legal_country_feature_restrictions_applied = 21;
 inline bool has_legal_country_feature_restrictions_applied() const;
 inline void clear_legal_country_feature_restrictions_applied();
 static const int kLegalCountryFeatureRestrictionsAppliedFieldNumber = 21;
 inline bool legal_country_feature_restrictions_applied() const;
 inline void set_legal_country_feature_restrictions_applied(bool value);
 
 // optional .bgs.protocol.account.v1.OptIns opt_ins = 22;
 inline bool has_opt_ins() const;
 inline void clear_opt_ins();
 static const int kOptInsFieldNumber = 22;
 inline const ::bgs::protocol::account::v1::OptIns& opt_ins() const;
 inline ::bgs::protocol::account::v1::OptIns* mutable_opt_ins();
 inline ::bgs::protocol::account::v1::OptIns* release_opt_ins();
 inline void set_allocated_opt_ins(::bgs::protocol::account::v1::OptIns* opt_ins);
 
 // @@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();
 inline void set_has_headless_account();
 inline void clear_has_headless_account();
 inline void set_has_test_account();
 inline void clear_has_test_account();
 inline void set_has_is_sms_protected();
 inline void clear_has_is_sms_protected();
 inline void set_has_ratings_board_minimum_age();
 inline void clear_has_ratings_board_minimum_age();
 inline void set_has_phone_number();
 inline void clear_has_phone_number();
 inline void set_has_birthdate();
 inline void clear_has_birthdate();
 inline void set_has_legal_country_feature_restrictions_applied();
 inline void clear_has_legal_country_feature_restrictions_applied();
 inline void set_has_opt_ins();
 inline void clear_has_opt_ins();
 
 ::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_;
 bool headless_account_;
 int identity_check_status_;
 ::std::string* email_;
 ::google::protobuf::uint32 ratings_board_minimum_age_;
 bool test_account_;
 bool is_sms_protected_;
 bool legal_country_feature_restrictions_applied_;
 ::std::string* phone_number_;
 ::std::string* birthdate_;
 ::bgs::protocol::account::v1::OptIns* opt_ins_;
 friend void TC_PROTO_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_PROTO_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;
 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_visible_for_view_friends = 4;
 inline bool has_is_visible_for_view_friends() const;
 inline void clear_is_visible_for_view_friends();
 static const int kIsVisibleForViewFriendsFieldNumber = 4;
 inline bool is_visible_for_view_friends() const;
 inline void set_is_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);
 
 // optional bool only_allow_friend_whispers = 7;
 inline bool has_only_allow_friend_whispers() const;
 inline void clear_only_allow_friend_whispers();
 static const int kOnlyAllowFriendWhispersFieldNumber = 7;
 inline bool only_allow_friend_whispers() const;
 inline void set_only_allow_friend_whispers(bool 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_visible_for_view_friends();
 inline void clear_has_is_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();
 inline void set_has_only_allow_friend_whispers();
 inline void clear_has_only_allow_friend_whispers();
 
 ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 bool is_using_rid_;
 bool is_visible_for_view_friends_;
 bool is_hidden_from_friend_finder_;
 bool only_allow_friend_whispers_;
 int game_info_privacy_;
 friend void TC_PROTO_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_PROTO_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;
 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();
 
 // optional bool can_join_group = 9;
 inline bool has_can_join_group() const;
 inline void clear_can_join_group();
 static const int kCanJoinGroupFieldNumber = 9;
 inline bool can_join_group() const;
 inline void set_can_join_group(bool value);
 
 // optional bool can_use_profile = 10;
 inline bool has_can_use_profile() const;
 inline void clear_can_use_profile();
 static const int kCanUseProfileFieldNumber = 10;
 inline bool can_use_profile() const;
 inline void set_can_use_profile(bool value);
 
 // @@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();
 inline void set_has_can_join_group();
 inline void clear_has_can_join_group();
 inline void set_has_can_use_profile();
 inline void clear_has_can_use_profile();
 
 ::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_;
 bool can_join_group_;
 bool can_use_profile_;
 friend void TC_PROTO_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_PROTO_API PlayScheduleRestriction : public ::google::protobuf::Message {
 public:
 PlayScheduleRestriction();
 virtual ~PlayScheduleRestriction();
 
 PlayScheduleRestriction(const PlayScheduleRestriction& from);
 
 inline PlayScheduleRestriction& operator=(const PlayScheduleRestriction& 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 PlayScheduleRestriction& default_instance();
 
 void Swap(PlayScheduleRestriction* other);
 
 // implements Message ----------------------------------------------
 
 PlayScheduleRestriction* New() 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 bool play_schedule = 1;
 inline int play_schedule_size() const;
 inline void clear_play_schedule();
 static const int kPlayScheduleFieldNumber = 1;
 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();
 
 // optional string timezone = 2;
 inline bool has_timezone() const;
 inline void clear_timezone();
 static const int kTimezoneFieldNumber = 2;
 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);
 
 // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.PlayScheduleRestriction)
 private:
 inline void set_has_timezone();
 inline void clear_has_timezone();
 
 ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::google::protobuf::RepeatedField< bool > play_schedule_;
 ::std::string* timezone_;
 friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
 friend void protobuf_AssignDesc_account_5ftypes_2eproto();
 friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
 
 void InitAsDefaultInstance();
 static PlayScheduleRestriction* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_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;
 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);
 
 // optional uint64 last_logout_time_ms = 12 [deprecated = true];
 inline bool has_last_logout_time_ms() const PROTOBUF_DEPRECATED;
 inline void clear_last_logout_time_ms() PROTOBUF_DEPRECATED;
 static const int kLastLogoutTimeMsFieldNumber = 12;
 inline ::google::protobuf::uint64 last_logout_time_ms() const PROTOBUF_DEPRECATED;
 inline void set_last_logout_time_ms(::google::protobuf::uint64 value) PROTOBUF_DEPRECATED;
 
 // @@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();
 inline void set_has_last_logout_time_ms();
 inline void clear_has_last_logout_time_ms();
 
 ::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::uint64 last_logout_time_ms_;
 ::google::protobuf::uint32 realm_permissions_;
 friend void TC_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_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;
 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 [deprecated = true];
 inline bool has_seconds_remaining_until_kick() const PROTOBUF_DEPRECATED;
 inline void clear_seconds_remaining_until_kick() PROTOBUF_DEPRECATED;
 static const int kSecondsRemainingUntilKickFieldNumber = 4;
 inline ::google::protobuf::uint32 seconds_remaining_until_kick() const PROTOBUF_DEPRECATED;
 inline void set_seconds_remaining_until_kick(::google::protobuf::uint32 value) PROTOBUF_DEPRECATED;
 
 // @@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_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_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;
 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);
 
 // optional .bgs.protocol.account.v1.IgrId igr_id = 9;
 inline bool has_igr_id() const;
 inline void clear_igr_id();
 static const int kIgrIdFieldNumber = 9;
 inline const ::bgs::protocol::account::v1::IgrId& igr_id() const;
 inline ::bgs::protocol::account::v1::IgrId* mutable_igr_id();
 inline ::bgs::protocol::account::v1::IgrId* release_igr_id();
 inline void set_allocated_igr_id(::bgs::protocol::account::v1::IgrId* igr_id);
 
 // optional fixed32 platform_id = 10;
 inline bool has_platform_id() const;
 inline void clear_platform_id();
 static const int kPlatformIdFieldNumber = 10;
 inline ::google::protobuf::uint32 platform_id() const;
 inline void set_platform_id(::google::protobuf::uint32 value);
 
 // optional bool igr_paid = 11;
 inline bool has_igr_paid() const;
 inline void clear_igr_paid();
 static const int kIgrPaidFieldNumber = 11;
 inline bool igr_paid() const;
 inline void set_igr_paid(bool 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();
 inline void set_has_igr_id();
 inline void clear_has_igr_id();
 inline void set_has_platform_id();
 inline void clear_has_platform_id();
 inline void set_has_igr_paid();
 inline void clear_has_igr_paid();
 
 ::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_;
 bool igr_paid_;
 ::google::protobuf::uint64 start_time_sec_;
 ::bgs::protocol::account::v1::IgrId* igr_id_;
 ::google::protobuf::uint32 platform_id_;
 friend void TC_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_API SecurityStatus : public ::google::protobuf::Message {
 public:
 SecurityStatus();
 virtual ~SecurityStatus();
 
 SecurityStatus(const SecurityStatus& from);
 
 inline SecurityStatus& operator=(const SecurityStatus& 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 SecurityStatus& default_instance();
 
 void Swap(SecurityStatus* other);
 
 // implements Message ----------------------------------------------
 
 SecurityStatus* New() 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 sms_protect_enabled = 1;
 inline bool has_sms_protect_enabled() const;
 inline void clear_sms_protect_enabled();
 static const int kSmsProtectEnabledFieldNumber = 1;
 inline bool sms_protect_enabled() const;
 inline void set_sms_protect_enabled(bool value);
 
 // optional bool email_verified = 2;
 inline bool has_email_verified() const;
 inline void clear_email_verified();
 static const int kEmailVerifiedFieldNumber = 2;
 inline bool email_verified() const;
 inline void set_email_verified(bool value);
 
 // optional bool authenticator_enabled = 3;
 inline bool has_authenticator_enabled() const;
 inline void clear_authenticator_enabled();
 static const int kAuthenticatorEnabledFieldNumber = 3;
 inline bool authenticator_enabled() const;
 inline void set_authenticator_enabled(bool value);
 
 // optional bool sqa_enabled = 4;
 inline bool has_sqa_enabled() const;
 inline void clear_sqa_enabled();
 static const int kSqaEnabledFieldNumber = 4;
 inline bool sqa_enabled() const;
 inline void set_sqa_enabled(bool value);
 
 // optional bool authenticator_required = 5;
 inline bool has_authenticator_required() const;
 inline void clear_authenticator_required();
 static const int kAuthenticatorRequiredFieldNumber = 5;
 inline bool authenticator_required() const;
 inline void set_authenticator_required(bool value);
 
 // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.SecurityStatus)
 private:
 inline void set_has_sms_protect_enabled();
 inline void clear_has_sms_protect_enabled();
 inline void set_has_email_verified();
 inline void clear_has_email_verified();
 inline void set_has_authenticator_enabled();
 inline void clear_has_authenticator_enabled();
 inline void set_has_sqa_enabled();
 inline void clear_has_sqa_enabled();
 inline void set_has_authenticator_required();
 inline void clear_has_authenticator_required();
 
 ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 bool sms_protect_enabled_;
 bool email_verified_;
 bool authenticator_enabled_;
 bool sqa_enabled_;
 bool authenticator_required_;
 friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
 friend void protobuf_AssignDesc_account_5ftypes_2eproto();
 friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
 
 void InitAsDefaultInstance();
 static SecurityStatus* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_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;
 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();
 
 // optional .bgs.protocol.account.v1.SecurityStatus security_status = 8;
 inline bool has_security_status() const;
 inline void clear_security_status();
 static const int kSecurityStatusFieldNumber = 8;
 inline const ::bgs::protocol::account::v1::SecurityStatus& security_status() const;
 inline ::bgs::protocol::account::v1::SecurityStatus* mutable_security_status();
 inline ::bgs::protocol::account::v1::SecurityStatus* release_security_status();
 inline void set_allocated_security_status(::bgs::protocol::account::v1::SecurityStatus* security_status);
 
 // optional .bgs.protocol.account.v1.PlayScheduleRestriction government_curfew = 9;
 inline bool has_government_curfew() const;
 inline void clear_government_curfew();
 static const int kGovernmentCurfewFieldNumber = 9;
 inline const ::bgs::protocol::account::v1::PlayScheduleRestriction& government_curfew() const;
 inline ::bgs::protocol::account::v1::PlayScheduleRestriction* mutable_government_curfew();
 inline ::bgs::protocol::account::v1::PlayScheduleRestriction* release_government_curfew();
 inline void set_allocated_government_curfew(::bgs::protocol::account::v1::PlayScheduleRestriction* government_curfew);
 
 // @@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();
 inline void set_has_security_status();
 inline void clear_has_security_status();
 inline void set_has_government_curfew();
 inline void clear_has_government_curfew();
 
 ::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_;
 ::bgs::protocol::account::v1::SecurityStatus* security_status_;
 ::bgs::protocol::account::v1::PlayScheduleRestriction* government_curfew_;
 friend void TC_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_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;
 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_PROTO_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_PROTO_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;
 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_PROTO_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_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API IgrId : public ::google::protobuf::Message {
 public:
 IgrId();
 virtual ~IgrId();
 
 IgrId(const IgrId& from);
 
 inline IgrId& operator=(const IgrId& 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 IgrId& default_instance();
 
 enum TypeCase {
 kGameAccount = 1,
 kExternalId = 2,
 kUuid = 3,
 TYPE_NOT_SET = 0,
 };
 
 void Swap(IgrId* other);
 
 // implements Message ----------------------------------------------
 
 IgrId* New() 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 [deprecated = true];
 inline bool has_game_account() const PROTOBUF_DEPRECATED;
 inline void clear_game_account() PROTOBUF_DEPRECATED;
 static const int kGameAccountFieldNumber = 1;
 inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const PROTOBUF_DEPRECATED;
 inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account() PROTOBUF_DEPRECATED;
 inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account() PROTOBUF_DEPRECATED;
 inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) PROTOBUF_DEPRECATED;
 
 // optional fixed32 external_id = 2;
 inline bool has_external_id() const;
 inline void clear_external_id();
 static const int kExternalIdFieldNumber = 2;
 inline ::google::protobuf::uint32 external_id() const;
 inline void set_external_id(::google::protobuf::uint32 value);
 
 // optional string uuid = 3;
 inline bool has_uuid() const;
 inline void clear_uuid();
 static const int kUuidFieldNumber = 3;
 inline const ::std::string& uuid() const;
 inline void set_uuid(const ::std::string& value);
 inline void set_uuid(const char* value);
 inline void set_uuid(const char* value, size_t size);
 inline ::std::string* mutable_uuid();
 inline ::std::string* release_uuid();
 inline void set_allocated_uuid(::std::string* uuid);
 
 inline TypeCase type_case() const;
 // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.IgrId)
 private:
 inline void set_has_game_account();
 inline void set_has_external_id();
 inline void set_has_uuid();
 
 inline bool has_type();
 void clear_type();
 inline void clear_has_type();
 
 ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 union TypeUnion {
 ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
 ::google::protobuf::uint32 external_id_;
 ::std::string* uuid_;
 } type_;
 ::google::protobuf::uint32 _oneof_case_[1];
 
 friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
 friend void protobuf_AssignDesc_account_5ftypes_2eproto();
 friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
 
 void InitAsDefaultInstance();
 static IgrId* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API IgrAddress : public ::google::protobuf::Message {
 public:
 IgrAddress();
 virtual ~IgrAddress();
 
 IgrAddress(const IgrAddress& from);
 
 inline IgrAddress& operator=(const IgrAddress& 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 IgrAddress& default_instance();
 
 void Swap(IgrAddress* other);
 
 // implements Message ----------------------------------------------
 
 IgrAddress* New() 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.IgrAddress)
 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_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
 friend void protobuf_AssignDesc_account_5ftypes_2eproto();
 friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
 
 void InitAsDefaultInstance();
 static IgrAddress* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API AccountPrivacySetting : public ::google::protobuf::Message {
 public:
 AccountPrivacySetting();
 virtual ~AccountPrivacySetting();
 
 AccountPrivacySetting(const AccountPrivacySetting& from);
 
 inline AccountPrivacySetting& operator=(const AccountPrivacySetting& 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 AccountPrivacySetting& default_instance();
 
 void Swap(AccountPrivacySetting* other);
 
 // implements Message ----------------------------------------------
 
 AccountPrivacySetting* New() 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_using_rid = 1;
 inline bool has_is_using_rid() const;
 inline void clear_is_using_rid();
 static const int kIsUsingRidFieldNumber = 1;
 inline bool is_using_rid() const;
 inline void set_is_using_rid(bool value);
 
 // optional bool is_visible_for_view_friends = 2;
 inline bool has_is_visible_for_view_friends() const;
 inline void clear_is_visible_for_view_friends();
 static const int kIsVisibleForViewFriendsFieldNumber = 2;
 inline bool is_visible_for_view_friends() const;
 inline void set_is_visible_for_view_friends(bool value);
 
 // optional bool is_hidden_from_friend_finder = 3;
 inline bool has_is_hidden_from_friend_finder() const;
 inline void clear_is_hidden_from_friend_finder();
 static const int kIsHiddenFromFriendFinderFieldNumber = 3;
 inline bool is_hidden_from_friend_finder() const;
 inline void set_is_hidden_from_friend_finder(bool value);
 
 // optional bool only_allow_friend_whispers = 4;
 inline bool has_only_allow_friend_whispers() const;
 inline void clear_only_allow_friend_whispers();
 static const int kOnlyAllowFriendWhispersFieldNumber = 4;
 inline bool only_allow_friend_whispers() const;
 inline void set_only_allow_friend_whispers(bool value);
 
 // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountPrivacySetting)
 private:
 inline void set_has_is_using_rid();
 inline void clear_has_is_using_rid();
 inline void set_has_is_visible_for_view_friends();
 inline void clear_has_is_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_only_allow_friend_whispers();
 inline void clear_has_only_allow_friend_whispers();
 
 ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 bool is_using_rid_;
 bool is_visible_for_view_friends_;
 bool is_hidden_from_friend_finder_;
 bool only_allow_friend_whispers_;
 friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
 friend void protobuf_AssignDesc_account_5ftypes_2eproto();
 friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
 
 void InitAsDefaultInstance();
 static AccountPrivacySetting* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_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;
 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 battle_tag = 1;
 inline bool has_battle_tag() const;
 inline void clear_battle_tag();
 static const int kBattleTagFieldNumber = 1;
 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 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 phone_number = 3;
 inline bool has_phone_number() const;
 inline void clear_phone_number();
 static const int kPhoneNumberFieldNumber = 3;
 inline const ::std::string& phone_number() const;
 inline void set_phone_number(const ::std::string& value);
 inline void set_phone_number(const char* value);
 inline void set_phone_number(const char* value, size_t size);
 inline ::std::string* mutable_phone_number();
 inline ::std::string* release_phone_number();
 inline void set_allocated_phone_number(::std::string* phone_number);
 
 // optional string full_name = 4;
 inline bool has_full_name() const;
 inline void clear_full_name();
 static const int kFullNameFieldNumber = 4;
 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 birthdate = 5;
 inline bool has_birthdate() const;
 inline void clear_birthdate();
 static const int kBirthdateFieldNumber = 5;
 inline const ::std::string& birthdate() const;
 inline void set_birthdate(const ::std::string& value);
 inline void set_birthdate(const char* value);
 inline void set_birthdate(const char* value, size_t size);
 inline ::std::string* mutable_birthdate();
 inline ::std::string* release_birthdate();
 inline void set_allocated_birthdate(::std::string* birthdate);
 
 // optional string country = 6;
 inline bool has_country() const;
 inline void clear_country();
 static const int kCountryFieldNumber = 6;
 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 string default_currency = 7;
 inline bool has_default_currency() const;
 inline void clear_default_currency();
 static const int kDefaultCurrencyFieldNumber = 7;
 inline const ::std::string& default_currency() const;
 inline void set_default_currency(const ::std::string& value);
 inline void set_default_currency(const char* value);
 inline void set_default_currency(const char* value, size_t size);
 inline ::std::string* mutable_default_currency();
 inline ::std::string* release_default_currency();
 inline void set_allocated_default_currency(::std::string* default_currency);
 
 // optional uint32 preferred_region = 8;
 inline bool has_preferred_region() const;
 inline void clear_preferred_region();
 static const int kPreferredRegionFieldNumber = 8;
 inline ::google::protobuf::uint32 preferred_region() const;
 inline void set_preferred_region(::google::protobuf::uint32 value);
 
 // optional uint32 ratings_board_minimum_age = 9;
 inline bool has_ratings_board_minimum_age() const;
 inline void clear_ratings_board_minimum_age();
 static const int kRatingsBoardMinimumAgeFieldNumber = 9;
 inline ::google::protobuf::uint32 ratings_board_minimum_age() const;
 inline void set_ratings_board_minimum_age(::google::protobuf::uint32 value);
 
 // optional bool has_parental_control = 10;
 inline bool has_has_parental_control() const;
 inline void clear_has_parental_control();
 static const int kHasParentalControlFieldNumber = 10;
 inline bool has_parental_control() const;
 inline void set_has_parental_control(bool value);
 
 // optional bool is_email_verified = 11;
 inline bool has_is_email_verified() const;
 inline void clear_is_email_verified();
 static const int kIsEmailVerifiedFieldNumber = 11;
 inline bool is_email_verified() const;
 inline void set_is_email_verified(bool value);
 
 // optional bool is_sms_protected = 12;
 inline bool has_is_sms_protected() const;
 inline void clear_is_sms_protected();
 static const int kIsSmsProtectedFieldNumber = 12;
 inline bool is_sms_protected() const;
 inline void set_is_sms_protected(bool value);
 
 // optional bool is_headless_account = 13;
 inline bool has_is_headless_account() const;
 inline void clear_is_headless_account();
 static const int kIsHeadlessAccountFieldNumber = 13;
 inline bool is_headless_account() const;
 inline void set_is_headless_account(bool value);
 
 // optional bool is_employee = 14;
 inline bool has_is_employee() const;
 inline void clear_is_employee();
 static const int kIsEmployeeFieldNumber = 14;
 inline bool is_employee() const;
 inline void set_is_employee(bool value);
 
 // optional bool is_test_account = 15;
 inline bool has_is_test_account() const;
 inline void clear_is_test_account();
 static const int kIsTestAccountFieldNumber = 15;
 inline bool is_test_account() const;
 inline void set_is_test_account(bool value);
 
 // optional .bgs.protocol.account.v1.AccountPrivacySetting privacy_setting = 16;
 inline bool has_privacy_setting() const;
 inline void clear_privacy_setting();
 static const int kPrivacySettingFieldNumber = 16;
 inline const ::bgs::protocol::account::v1::AccountPrivacySetting& privacy_setting() const;
 inline ::bgs::protocol::account::v1::AccountPrivacySetting* mutable_privacy_setting();
 inline ::bgs::protocol::account::v1::AccountPrivacySetting* release_privacy_setting();
 inline void set_allocated_privacy_setting(::bgs::protocol::account::v1::AccountPrivacySetting* privacy_setting);
 
 // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountInfo)
 private:
 inline void set_has_battle_tag();
 inline void clear_has_battle_tag();
 inline void set_has_email();
 inline void clear_has_email();
 inline void set_has_phone_number();
 inline void clear_has_phone_number();
 inline void set_has_full_name();
 inline void clear_has_full_name();
 inline void set_has_birthdate();
 inline void clear_has_birthdate();
 inline void set_has_country();
 inline void clear_has_country();
 inline void set_has_default_currency();
 inline void clear_has_default_currency();
 inline void set_has_preferred_region();
 inline void clear_has_preferred_region();
 inline void set_has_ratings_board_minimum_age();
 inline void clear_has_ratings_board_minimum_age();
 inline void set_has_has_parental_control();
 inline void clear_has_has_parental_control();
 inline void set_has_is_email_verified();
 inline void clear_has_is_email_verified();
 inline void set_has_is_sms_protected();
 inline void clear_has_is_sms_protected();
 inline void set_has_is_headless_account();
 inline void clear_has_is_headless_account();
 inline void set_has_is_employee();
 inline void clear_has_is_employee();
 inline void set_has_is_test_account();
 inline void clear_has_is_test_account();
 inline void set_has_privacy_setting();
 inline void clear_has_privacy_setting();
 
 ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::std::string* battle_tag_;
 ::std::string* email_;
 ::std::string* phone_number_;
 ::std::string* full_name_;
 ::std::string* birthdate_;
 ::std::string* country_;
 ::std::string* default_currency_;
 ::google::protobuf::uint32 preferred_region_;
 ::google::protobuf::uint32 ratings_board_minimum_age_;
 bool has_parental_control_;
 bool is_email_verified_;
 bool is_sms_protected_;
 bool is_headless_account_;
 bool is_employee_;
 bool is_test_account_;
 ::bgs::protocol::account::v1::AccountPrivacySetting* privacy_setting_;
 friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
 friend void protobuf_AssignDesc_account_5ftypes_2eproto();
 friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
 
 void InitAsDefaultInstance();
 static AccountInfo* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API RestrictionStatus : public ::google::protobuf::Message {
 public:
 RestrictionStatus();
 virtual ~RestrictionStatus();
 
 RestrictionStatus(const RestrictionStatus& from);
 
 inline RestrictionStatus& operator=(const RestrictionStatus& 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 RestrictionStatus& default_instance();
 
 void Swap(RestrictionStatus* other);
 
 // implements Message ----------------------------------------------
 
 RestrictionStatus* New() 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 active = 1;
 inline bool has_active() const;
 inline void clear_active();
 static const int kActiveFieldNumber = 1;
 inline bool active() const;
 inline void set_active(bool value);
 
 // optional uint64 expiration_us = 2;
 inline bool has_expiration_us() const;
 inline void clear_expiration_us();
 static const int kExpirationUsFieldNumber = 2;
 inline ::google::protobuf::uint64 expiration_us() const;
 inline void set_expiration_us(::google::protobuf::uint64 value);
 
 // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.RestrictionStatus)
 private:
 inline void set_has_active();
 inline void clear_has_active();
 inline void set_has_expiration_us();
 inline void clear_has_expiration_us();
 
 ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::google::protobuf::uint64 expiration_us_;
 bool active_;
 friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
 friend void protobuf_AssignDesc_account_5ftypes_2eproto();
 friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
 
 void InitAsDefaultInstance();
 static RestrictionStatus* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API AccountPlatformRestrictionInfo : public ::google::protobuf::Message {
 public:
 AccountPlatformRestrictionInfo();
 virtual ~AccountPlatformRestrictionInfo();
 
 AccountPlatformRestrictionInfo(const AccountPlatformRestrictionInfo& from);
 
 inline AccountPlatformRestrictionInfo& operator=(const AccountPlatformRestrictionInfo& 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 AccountPlatformRestrictionInfo& default_instance();
 
 void Swap(AccountPlatformRestrictionInfo* other);
 
 // implements Message ----------------------------------------------
 
 AccountPlatformRestrictionInfo* New() 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.RestrictionStatus squelched = 2;
 inline bool has_squelched() const;
 inline void clear_squelched();
 static const int kSquelchedFieldNumber = 2;
 inline const ::bgs::protocol::account::v1::RestrictionStatus& squelched() const;
 inline ::bgs::protocol::account::v1::RestrictionStatus* mutable_squelched();
 inline ::bgs::protocol::account::v1::RestrictionStatus* release_squelched();
 inline void set_allocated_squelched(::bgs::protocol::account::v1::RestrictionStatus* squelched);
 
 // optional .bgs.protocol.account.v1.RestrictionStatus legal_country_feature_restrictions_applied = 3;
 inline bool has_legal_country_feature_restrictions_applied() const;
 inline void clear_legal_country_feature_restrictions_applied();
 static const int kLegalCountryFeatureRestrictionsAppliedFieldNumber = 3;
 inline const ::bgs::protocol::account::v1::RestrictionStatus& legal_country_feature_restrictions_applied() const;
 inline ::bgs::protocol::account::v1::RestrictionStatus* mutable_legal_country_feature_restrictions_applied();
 inline ::bgs::protocol::account::v1::RestrictionStatus* release_legal_country_feature_restrictions_applied();
 inline void set_allocated_legal_country_feature_restrictions_applied(::bgs::protocol::account::v1::RestrictionStatus* legal_country_feature_restrictions_applied);
 
 // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountPlatformRestrictionInfo)
 private:
 inline void set_has_squelched();
 inline void clear_has_squelched();
 inline void set_has_legal_country_feature_restrictions_applied();
 inline void clear_has_legal_country_feature_restrictions_applied();
 
 ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
 ::google::protobuf::uint32 _has_bits_[1];
 mutable int _cached_size_;
 ::bgs::protocol::account::v1::RestrictionStatus* squelched_;
 ::bgs::protocol::account::v1::RestrictionStatus* legal_country_feature_restrictions_applied_;
 friend void TC_PROTO_API protobuf_AddDesc_account_5ftypes_2eproto();
 friend void protobuf_AssignDesc_account_5ftypes_2eproto();
 friend void protobuf_ShutdownFile_account_5ftypes_2eproto();
 
 void InitAsDefaultInstance();
 static AccountPlatformRestrictionInfo* 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)
}
 
// -------------------------------------------------------------------
 
// 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)
}
 
// -------------------------------------------------------------------
 
// 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 string phone_number = 5;
inline bool AccountReference::has_phone_number() const {
 return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void AccountReference::set_has_phone_number() {
 _has_bits_[0] |= 0x00000010u;
}
inline void AccountReference::clear_has_phone_number() {
 _has_bits_[0] &= ~0x00000010u;
}
inline void AccountReference::clear_phone_number() {
 if (phone_number_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 phone_number_->clear();
 }
 clear_has_phone_number();
}
inline const ::std::string& AccountReference::phone_number() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountReference.phone_number)
 return *phone_number_;
}
inline void AccountReference::set_phone_number(const ::std::string& value) {
 set_has_phone_number();
 if (phone_number_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 phone_number_ = new ::std::string;
 }
 phone_number_->assign(value);
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountReference.phone_number)
}
inline void AccountReference::set_phone_number(const char* value) {
 set_has_phone_number();
 if (phone_number_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 phone_number_ = new ::std::string;
 }
 phone_number_->assign(value);
 // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountReference.phone_number)
}
inline void AccountReference::set_phone_number(const char* value, size_t size) {
 set_has_phone_number();
 if (phone_number_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 phone_number_ = new ::std::string;
 }
 phone_number_->assign(reinterpret_cast<const char*>(value), size);
 // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountReference.phone_number)
}
inline ::std::string* AccountReference::mutable_phone_number() {
 set_has_phone_number();
 if (phone_number_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 phone_number_ = new ::std::string;
 }
 // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountReference.phone_number)
 return phone_number_;
}
inline ::std::string* AccountReference::release_phone_number() {
 clear_has_phone_number();
 if (phone_number_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 return NULL;
 } else {
 ::std::string* temp = phone_number_;
 phone_number_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 return temp;
 }
}
inline void AccountReference::set_allocated_phone_number(::std::string* phone_number) {
 if (phone_number_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 delete phone_number_;
 }
 if (phone_number) {
 set_has_phone_number();
 phone_number_ = phone_number;
 } else {
 clear_has_phone_number();
 phone_number_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 }
 // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountReference.phone_number)
}
 
// optional uint32 region = 10 [default = 0];
inline bool AccountReference::has_region() const {
 return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void AccountReference::set_has_region() {
 _has_bits_[0] |= 0x00000020u;
}
inline void AccountReference::clear_has_region() {
 _has_bits_[0] &= ~0x00000020u;
}
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)
}
 
// -------------------------------------------------------------------
 
// 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_;
}
 
// optional fixed32 security_status_tag = 12;
inline bool AccountFieldTags::has_security_status_tag() const {
 return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void AccountFieldTags::set_has_security_status_tag() {
 _has_bits_[0] |= 0x00000040u;
}
inline void AccountFieldTags::clear_has_security_status_tag() {
 _has_bits_[0] &= ~0x00000040u;
}
inline void AccountFieldTags::clear_security_status_tag() {
 security_status_tag_ = 0u;
 clear_has_security_status_tag();
}
inline ::google::protobuf::uint32 AccountFieldTags::security_status_tag() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldTags.security_status_tag)
 return security_status_tag_;
}
inline void AccountFieldTags::set_security_status_tag(::google::protobuf::uint32 value) {
 set_has_security_status_tag();
 security_status_tag_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldTags.security_status_tag)
}
 
// -------------------------------------------------------------------
 
// 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)
}
 
// optional bool field_security_status = 9;
inline bool AccountFieldOptions::has_field_security_status() const {
 return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void AccountFieldOptions::set_has_field_security_status() {
 _has_bits_[0] |= 0x00000080u;
}
inline void AccountFieldOptions::clear_has_field_security_status() {
 _has_bits_[0] &= ~0x00000080u;
}
inline void AccountFieldOptions::clear_field_security_status() {
 field_security_status_ = false;
 clear_has_field_security_status();
}
inline bool AccountFieldOptions::field_security_status() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountFieldOptions.field_security_status)
 return field_security_status_;
}
inline void AccountFieldOptions::set_field_security_status(bool value) {
 set_has_field_security_status();
 field_security_status_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountFieldOptions.field_security_status)
}
 
// -------------------------------------------------------------------
 
// 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)
}
 
// -------------------------------------------------------------------
 
// OptIns
 
// repeated uint64 ids = 1 [packed = true];
inline int OptIns::ids_size() const {
 return ids_.size();
}
inline void OptIns::clear_ids() {
 ids_.Clear();
}
inline ::google::protobuf::uint64 OptIns::ids(int index) const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.OptIns.ids)
 return ids_.Get(index);
}
inline void OptIns::set_ids(int index, ::google::protobuf::uint64 value) {
 ids_.Set(index, value);
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.OptIns.ids)
}
inline void OptIns::add_ids(::google::protobuf::uint64 value) {
 ids_.Add(value);
 // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.OptIns.ids)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
OptIns::ids() const {
 // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.OptIns.ids)
 return ids_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
OptIns::mutable_ids() {
 // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.OptIns.ids)
 return &ids_;
}
 
// -------------------------------------------------------------------
 
// 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)
}
 
// optional bool headless_account = 14;
inline bool AccountLevelInfo::has_headless_account() const {
 return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void AccountLevelInfo::set_has_headless_account() {
 _has_bits_[0] |= 0x00000800u;
}
inline void AccountLevelInfo::clear_has_headless_account() {
 _has_bits_[0] &= ~0x00000800u;
}
inline void AccountLevelInfo::clear_headless_account() {
 headless_account_ = false;
 clear_has_headless_account();
}
inline bool AccountLevelInfo::headless_account() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.headless_account)
 return headless_account_;
}
inline void AccountLevelInfo::set_headless_account(bool value) {
 set_has_headless_account();
 headless_account_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.headless_account)
}
 
// optional bool test_account = 15;
inline bool AccountLevelInfo::has_test_account() const {
 return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void AccountLevelInfo::set_has_test_account() {
 _has_bits_[0] |= 0x00001000u;
}
inline void AccountLevelInfo::clear_has_test_account() {
 _has_bits_[0] &= ~0x00001000u;
}
inline void AccountLevelInfo::clear_test_account() {
 test_account_ = false;
 clear_has_test_account();
}
inline bool AccountLevelInfo::test_account() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.test_account)
 return test_account_;
}
inline void AccountLevelInfo::set_test_account(bool value) {
 set_has_test_account();
 test_account_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.test_account)
}
 
// optional bool is_sms_protected = 17;
inline bool AccountLevelInfo::has_is_sms_protected() const {
 return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void AccountLevelInfo::set_has_is_sms_protected() {
 _has_bits_[0] |= 0x00002000u;
}
inline void AccountLevelInfo::clear_has_is_sms_protected() {
 _has_bits_[0] &= ~0x00002000u;
}
inline void AccountLevelInfo::clear_is_sms_protected() {
 is_sms_protected_ = false;
 clear_has_is_sms_protected();
}
inline bool AccountLevelInfo::is_sms_protected() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.is_sms_protected)
 return is_sms_protected_;
}
inline void AccountLevelInfo::set_is_sms_protected(bool value) {
 set_has_is_sms_protected();
 is_sms_protected_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.is_sms_protected)
}
 
// optional uint32 ratings_board_minimum_age = 18;
inline bool AccountLevelInfo::has_ratings_board_minimum_age() const {
 return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void AccountLevelInfo::set_has_ratings_board_minimum_age() {
 _has_bits_[0] |= 0x00004000u;
}
inline void AccountLevelInfo::clear_has_ratings_board_minimum_age() {
 _has_bits_[0] &= ~0x00004000u;
}
inline void AccountLevelInfo::clear_ratings_board_minimum_age() {
 ratings_board_minimum_age_ = 0u;
 clear_has_ratings_board_minimum_age();
}
inline ::google::protobuf::uint32 AccountLevelInfo::ratings_board_minimum_age() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.ratings_board_minimum_age)
 return ratings_board_minimum_age_;
}
inline void AccountLevelInfo::set_ratings_board_minimum_age(::google::protobuf::uint32 value) {
 set_has_ratings_board_minimum_age();
 ratings_board_minimum_age_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.ratings_board_minimum_age)
}
 
// optional string phone_number = 19;
inline bool AccountLevelInfo::has_phone_number() const {
 return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void AccountLevelInfo::set_has_phone_number() {
 _has_bits_[0] |= 0x00008000u;
}
inline void AccountLevelInfo::clear_has_phone_number() {
 _has_bits_[0] &= ~0x00008000u;
}
inline void AccountLevelInfo::clear_phone_number() {
 if (phone_number_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 phone_number_->clear();
 }
 clear_has_phone_number();
}
inline const ::std::string& AccountLevelInfo::phone_number() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.phone_number)
 return *phone_number_;
}
inline void AccountLevelInfo::set_phone_number(const ::std::string& value) {
 set_has_phone_number();
 if (phone_number_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 phone_number_ = new ::std::string;
 }
 phone_number_->assign(value);
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.phone_number)
}
inline void AccountLevelInfo::set_phone_number(const char* value) {
 set_has_phone_number();
 if (phone_number_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 phone_number_ = new ::std::string;
 }
 phone_number_->assign(value);
 // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountLevelInfo.phone_number)
}
inline void AccountLevelInfo::set_phone_number(const char* value, size_t size) {
 set_has_phone_number();
 if (phone_number_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 phone_number_ = new ::std::string;
 }
 phone_number_->assign(reinterpret_cast<const char*>(value), size);
 // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountLevelInfo.phone_number)
}
inline ::std::string* AccountLevelInfo::mutable_phone_number() {
 set_has_phone_number();
 if (phone_number_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 phone_number_ = new ::std::string;
 }
 // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountLevelInfo.phone_number)
 return phone_number_;
}
inline ::std::string* AccountLevelInfo::release_phone_number() {
 clear_has_phone_number();
 if (phone_number_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 return NULL;
 } else {
 ::std::string* temp = phone_number_;
 phone_number_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 return temp;
 }
}
inline void AccountLevelInfo::set_allocated_phone_number(::std::string* phone_number) {
 if (phone_number_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 delete phone_number_;
 }
 if (phone_number) {
 set_has_phone_number();
 phone_number_ = phone_number;
 } else {
 clear_has_phone_number();
 phone_number_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 }
 // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountLevelInfo.phone_number)
}
 
// optional string birthdate = 20;
inline bool AccountLevelInfo::has_birthdate() const {
 return (_has_bits_[0] & 0x00010000u) != 0;
}
inline void AccountLevelInfo::set_has_birthdate() {
 _has_bits_[0] |= 0x00010000u;
}
inline void AccountLevelInfo::clear_has_birthdate() {
 _has_bits_[0] &= ~0x00010000u;
}
inline void AccountLevelInfo::clear_birthdate() {
 if (birthdate_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 birthdate_->clear();
 }
 clear_has_birthdate();
}
inline const ::std::string& AccountLevelInfo::birthdate() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.birthdate)
 return *birthdate_;
}
inline void AccountLevelInfo::set_birthdate(const ::std::string& value) {
 set_has_birthdate();
 if (birthdate_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 birthdate_ = new ::std::string;
 }
 birthdate_->assign(value);
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.birthdate)
}
inline void AccountLevelInfo::set_birthdate(const char* value) {
 set_has_birthdate();
 if (birthdate_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 birthdate_ = new ::std::string;
 }
 birthdate_->assign(value);
 // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountLevelInfo.birthdate)
}
inline void AccountLevelInfo::set_birthdate(const char* value, size_t size) {
 set_has_birthdate();
 if (birthdate_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 birthdate_ = new ::std::string;
 }
 birthdate_->assign(reinterpret_cast<const char*>(value), size);
 // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountLevelInfo.birthdate)
}
inline ::std::string* AccountLevelInfo::mutable_birthdate() {
 set_has_birthdate();
 if (birthdate_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 birthdate_ = new ::std::string;
 }
 // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountLevelInfo.birthdate)
 return birthdate_;
}
inline ::std::string* AccountLevelInfo::release_birthdate() {
 clear_has_birthdate();
 if (birthdate_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 return NULL;
 } else {
 ::std::string* temp = birthdate_;
 birthdate_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 return temp;
 }
}
inline void AccountLevelInfo::set_allocated_birthdate(::std::string* birthdate) {
 if (birthdate_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 delete birthdate_;
 }
 if (birthdate) {
 set_has_birthdate();
 birthdate_ = birthdate;
 } else {
 clear_has_birthdate();
 birthdate_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 }
 // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountLevelInfo.birthdate)
}
 
// optional bool legal_country_feature_restrictions_applied = 21;
inline bool AccountLevelInfo::has_legal_country_feature_restrictions_applied() const {
 return (_has_bits_[0] & 0x00020000u) != 0;
}
inline void AccountLevelInfo::set_has_legal_country_feature_restrictions_applied() {
 _has_bits_[0] |= 0x00020000u;
}
inline void AccountLevelInfo::clear_has_legal_country_feature_restrictions_applied() {
 _has_bits_[0] &= ~0x00020000u;
}
inline void AccountLevelInfo::clear_legal_country_feature_restrictions_applied() {
 legal_country_feature_restrictions_applied_ = false;
 clear_has_legal_country_feature_restrictions_applied();
}
inline bool AccountLevelInfo::legal_country_feature_restrictions_applied() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.legal_country_feature_restrictions_applied)
 return legal_country_feature_restrictions_applied_;
}
inline void AccountLevelInfo::set_legal_country_feature_restrictions_applied(bool value) {
 set_has_legal_country_feature_restrictions_applied();
 legal_country_feature_restrictions_applied_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountLevelInfo.legal_country_feature_restrictions_applied)
}
 
// optional .bgs.protocol.account.v1.OptIns opt_ins = 22;
inline bool AccountLevelInfo::has_opt_ins() const {
 return (_has_bits_[0] & 0x00040000u) != 0;
}
inline void AccountLevelInfo::set_has_opt_ins() {
 _has_bits_[0] |= 0x00040000u;
}
inline void AccountLevelInfo::clear_has_opt_ins() {
 _has_bits_[0] &= ~0x00040000u;
}
inline void AccountLevelInfo::clear_opt_ins() {
 if (opt_ins_ != NULL) opt_ins_->::bgs::protocol::account::v1::OptIns::Clear();
 clear_has_opt_ins();
}
inline const ::bgs::protocol::account::v1::OptIns& AccountLevelInfo::opt_ins() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountLevelInfo.opt_ins)
 return opt_ins_ != NULL ? *opt_ins_ : *default_instance_->opt_ins_;
}
inline ::bgs::protocol::account::v1::OptIns* AccountLevelInfo::mutable_opt_ins() {
 set_has_opt_ins();
 if (opt_ins_ == NULL) opt_ins_ = new ::bgs::protocol::account::v1::OptIns;
 // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountLevelInfo.opt_ins)
 return opt_ins_;
}
inline ::bgs::protocol::account::v1::OptIns* AccountLevelInfo::release_opt_ins() {
 clear_has_opt_ins();
 ::bgs::protocol::account::v1::OptIns* temp = opt_ins_;
 opt_ins_ = NULL;
 return temp;
}
inline void AccountLevelInfo::set_allocated_opt_ins(::bgs::protocol::account::v1::OptIns* opt_ins) {
 delete opt_ins_;
 opt_ins_ = opt_ins;
 if (opt_ins) {
 set_has_opt_ins();
 } else {
 clear_has_opt_ins();
 }
 // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountLevelInfo.opt_ins)
}
 
// -------------------------------------------------------------------
 
// 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_visible_for_view_friends = 4;
inline bool PrivacyInfo::has_is_visible_for_view_friends() const {
 return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PrivacyInfo::set_has_is_visible_for_view_friends() {
 _has_bits_[0] |= 0x00000002u;
}
inline void PrivacyInfo::clear_has_is_visible_for_view_friends() {
 _has_bits_[0] &= ~0x00000002u;
}
inline void PrivacyInfo::clear_is_visible_for_view_friends() {
 is_visible_for_view_friends_ = false;
 clear_has_is_visible_for_view_friends();
}
inline bool PrivacyInfo::is_visible_for_view_friends() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.PrivacyInfo.is_visible_for_view_friends)
 return is_visible_for_view_friends_;
}
inline void PrivacyInfo::set_is_visible_for_view_friends(bool value) {
 set_has_is_visible_for_view_friends();
 is_visible_for_view_friends_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.PrivacyInfo.is_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)
}
 
// optional bool only_allow_friend_whispers = 7;
inline bool PrivacyInfo::has_only_allow_friend_whispers() const {
 return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void PrivacyInfo::set_has_only_allow_friend_whispers() {
 _has_bits_[0] |= 0x00000010u;
}
inline void PrivacyInfo::clear_has_only_allow_friend_whispers() {
 _has_bits_[0] &= ~0x00000010u;
}
inline void PrivacyInfo::clear_only_allow_friend_whispers() {
 only_allow_friend_whispers_ = false;
 clear_has_only_allow_friend_whispers();
}
inline bool PrivacyInfo::only_allow_friend_whispers() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.PrivacyInfo.only_allow_friend_whispers)
 return only_allow_friend_whispers_;
}
inline void PrivacyInfo::set_only_allow_friend_whispers(bool value) {
 set_has_only_allow_friend_whispers();
 only_allow_friend_whispers_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.PrivacyInfo.only_allow_friend_whispers)
}
 
// -------------------------------------------------------------------
 
// 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_;
}
 
// optional bool can_join_group = 9;
inline bool ParentalControlInfo::has_can_join_group() const {
 return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ParentalControlInfo::set_has_can_join_group() {
 _has_bits_[0] |= 0x00000040u;
}
inline void ParentalControlInfo::clear_has_can_join_group() {
 _has_bits_[0] &= ~0x00000040u;
}
inline void ParentalControlInfo::clear_can_join_group() {
 can_join_group_ = false;
 clear_has_can_join_group();
}
inline bool ParentalControlInfo::can_join_group() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ParentalControlInfo.can_join_group)
 return can_join_group_;
}
inline void ParentalControlInfo::set_can_join_group(bool value) {
 set_has_can_join_group();
 can_join_group_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ParentalControlInfo.can_join_group)
}
 
// optional bool can_use_profile = 10;
inline bool ParentalControlInfo::has_can_use_profile() const {
 return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ParentalControlInfo::set_has_can_use_profile() {
 _has_bits_[0] |= 0x00000080u;
}
inline void ParentalControlInfo::clear_has_can_use_profile() {
 _has_bits_[0] &= ~0x00000080u;
}
inline void ParentalControlInfo::clear_can_use_profile() {
 can_use_profile_ = false;
 clear_has_can_use_profile();
}
inline bool ParentalControlInfo::can_use_profile() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ParentalControlInfo.can_use_profile)
 return can_use_profile_;
}
inline void ParentalControlInfo::set_can_use_profile(bool value) {
 set_has_can_use_profile();
 can_use_profile_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ParentalControlInfo.can_use_profile)
}
 
// -------------------------------------------------------------------
 
// PlayScheduleRestriction
 
// repeated bool play_schedule = 1;
inline int PlayScheduleRestriction::play_schedule_size() const {
 return play_schedule_.size();
}
inline void PlayScheduleRestriction::clear_play_schedule() {
 play_schedule_.Clear();
}
inline bool PlayScheduleRestriction::play_schedule(int index) const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.PlayScheduleRestriction.play_schedule)
 return play_schedule_.Get(index);
}
inline void PlayScheduleRestriction::set_play_schedule(int index, bool value) {
 play_schedule_.Set(index, value);
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.PlayScheduleRestriction.play_schedule)
}
inline void PlayScheduleRestriction::add_play_schedule(bool value) {
 play_schedule_.Add(value);
 // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.PlayScheduleRestriction.play_schedule)
}
inline const ::google::protobuf::RepeatedField< bool >&
PlayScheduleRestriction::play_schedule() const {
 // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.PlayScheduleRestriction.play_schedule)
 return play_schedule_;
}
inline ::google::protobuf::RepeatedField< bool >*
PlayScheduleRestriction::mutable_play_schedule() {
 // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.PlayScheduleRestriction.play_schedule)
 return &play_schedule_;
}
 
// optional string timezone = 2;
inline bool PlayScheduleRestriction::has_timezone() const {
 return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void PlayScheduleRestriction::set_has_timezone() {
 _has_bits_[0] |= 0x00000002u;
}
inline void PlayScheduleRestriction::clear_has_timezone() {
 _has_bits_[0] &= ~0x00000002u;
}
inline void PlayScheduleRestriction::clear_timezone() {
 if (timezone_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 timezone_->clear();
 }
 clear_has_timezone();
}
inline const ::std::string& PlayScheduleRestriction::timezone() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.PlayScheduleRestriction.timezone)
 return *timezone_;
}
inline void PlayScheduleRestriction::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.PlayScheduleRestriction.timezone)
}
inline void PlayScheduleRestriction::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.PlayScheduleRestriction.timezone)
}
inline void PlayScheduleRestriction::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.PlayScheduleRestriction.timezone)
}
inline ::std::string* PlayScheduleRestriction::mutable_timezone() {
 set_has_timezone();
 if (timezone_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 timezone_ = new ::std::string;
 }
 // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.PlayScheduleRestriction.timezone)
 return timezone_;
}
inline ::std::string* PlayScheduleRestriction::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 PlayScheduleRestriction::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.PlayScheduleRestriction.timezone)
}
 
// -------------------------------------------------------------------
 
// 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)
}
 
// optional uint64 last_logout_time_ms = 12 [deprecated = true];
inline bool GameLevelInfo::has_last_logout_time_ms() const {
 return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void GameLevelInfo::set_has_last_logout_time_ms() {
 _has_bits_[0] |= 0x00000100u;
}
inline void GameLevelInfo::clear_has_last_logout_time_ms() {
 _has_bits_[0] &= ~0x00000100u;
}
inline void GameLevelInfo::clear_last_logout_time_ms() {
 last_logout_time_ms_ = GOOGLE_ULONGLONG(0);
 clear_has_last_logout_time_ms();
}
inline ::google::protobuf::uint64 GameLevelInfo::last_logout_time_ms() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameLevelInfo.last_logout_time_ms)
 return last_logout_time_ms_;
}
inline void GameLevelInfo::set_last_logout_time_ms(::google::protobuf::uint64 value) {
 set_has_last_logout_time_ms();
 last_logout_time_ms_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameLevelInfo.last_logout_time_ms)
}
 
// -------------------------------------------------------------------
 
// 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 [deprecated = true];
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)
}
 
// optional .bgs.protocol.account.v1.IgrId igr_id = 9;
inline bool GameSessionInfo::has_igr_id() const {
 return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void GameSessionInfo::set_has_igr_id() {
 _has_bits_[0] |= 0x00000040u;
}
inline void GameSessionInfo::clear_has_igr_id() {
 _has_bits_[0] &= ~0x00000040u;
}
inline void GameSessionInfo::clear_igr_id() {
 if (igr_id_ != NULL) igr_id_->::bgs::protocol::account::v1::IgrId::Clear();
 clear_has_igr_id();
}
inline const ::bgs::protocol::account::v1::IgrId& GameSessionInfo::igr_id() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionInfo.igr_id)
 return igr_id_ != NULL ? *igr_id_ : *default_instance_->igr_id_;
}
inline ::bgs::protocol::account::v1::IgrId* GameSessionInfo::mutable_igr_id() {
 set_has_igr_id();
 if (igr_id_ == NULL) igr_id_ = new ::bgs::protocol::account::v1::IgrId;
 // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameSessionInfo.igr_id)
 return igr_id_;
}
inline ::bgs::protocol::account::v1::IgrId* GameSessionInfo::release_igr_id() {
 clear_has_igr_id();
 ::bgs::protocol::account::v1::IgrId* temp = igr_id_;
 igr_id_ = NULL;
 return temp;
}
inline void GameSessionInfo::set_allocated_igr_id(::bgs::protocol::account::v1::IgrId* igr_id) {
 delete igr_id_;
 igr_id_ = igr_id;
 if (igr_id) {
 set_has_igr_id();
 } else {
 clear_has_igr_id();
 }
 // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameSessionInfo.igr_id)
}
 
// optional fixed32 platform_id = 10;
inline bool GameSessionInfo::has_platform_id() const {
 return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void GameSessionInfo::set_has_platform_id() {
 _has_bits_[0] |= 0x00000080u;
}
inline void GameSessionInfo::clear_has_platform_id() {
 _has_bits_[0] &= ~0x00000080u;
}
inline void GameSessionInfo::clear_platform_id() {
 platform_id_ = 0u;
 clear_has_platform_id();
}
inline ::google::protobuf::uint32 GameSessionInfo::platform_id() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionInfo.platform_id)
 return platform_id_;
}
inline void GameSessionInfo::set_platform_id(::google::protobuf::uint32 value) {
 set_has_platform_id();
 platform_id_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionInfo.platform_id)
}
 
// optional bool igr_paid = 11;
inline bool GameSessionInfo::has_igr_paid() const {
 return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void GameSessionInfo::set_has_igr_paid() {
 _has_bits_[0] |= 0x00000100u;
}
inline void GameSessionInfo::clear_has_igr_paid() {
 _has_bits_[0] &= ~0x00000100u;
}
inline void GameSessionInfo::clear_igr_paid() {
 igr_paid_ = false;
 clear_has_igr_paid();
}
inline bool GameSessionInfo::igr_paid() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameSessionInfo.igr_paid)
 return igr_paid_;
}
inline void GameSessionInfo::set_igr_paid(bool value) {
 set_has_igr_paid();
 igr_paid_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameSessionInfo.igr_paid)
}
 
// -------------------------------------------------------------------
 
// 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_;
}
 
// -------------------------------------------------------------------
 
// SecurityStatus
 
// optional bool sms_protect_enabled = 1;
inline bool SecurityStatus::has_sms_protect_enabled() const {
 return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SecurityStatus::set_has_sms_protect_enabled() {
 _has_bits_[0] |= 0x00000001u;
}
inline void SecurityStatus::clear_has_sms_protect_enabled() {
 _has_bits_[0] &= ~0x00000001u;
}
inline void SecurityStatus::clear_sms_protect_enabled() {
 sms_protect_enabled_ = false;
 clear_has_sms_protect_enabled();
}
inline bool SecurityStatus::sms_protect_enabled() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SecurityStatus.sms_protect_enabled)
 return sms_protect_enabled_;
}
inline void SecurityStatus::set_sms_protect_enabled(bool value) {
 set_has_sms_protect_enabled();
 sms_protect_enabled_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.SecurityStatus.sms_protect_enabled)
}
 
// optional bool email_verified = 2;
inline bool SecurityStatus::has_email_verified() const {
 return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SecurityStatus::set_has_email_verified() {
 _has_bits_[0] |= 0x00000002u;
}
inline void SecurityStatus::clear_has_email_verified() {
 _has_bits_[0] &= ~0x00000002u;
}
inline void SecurityStatus::clear_email_verified() {
 email_verified_ = false;
 clear_has_email_verified();
}
inline bool SecurityStatus::email_verified() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SecurityStatus.email_verified)
 return email_verified_;
}
inline void SecurityStatus::set_email_verified(bool value) {
 set_has_email_verified();
 email_verified_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.SecurityStatus.email_verified)
}
 
// optional bool authenticator_enabled = 3;
inline bool SecurityStatus::has_authenticator_enabled() const {
 return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SecurityStatus::set_has_authenticator_enabled() {
 _has_bits_[0] |= 0x00000004u;
}
inline void SecurityStatus::clear_has_authenticator_enabled() {
 _has_bits_[0] &= ~0x00000004u;
}
inline void SecurityStatus::clear_authenticator_enabled() {
 authenticator_enabled_ = false;
 clear_has_authenticator_enabled();
}
inline bool SecurityStatus::authenticator_enabled() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SecurityStatus.authenticator_enabled)
 return authenticator_enabled_;
}
inline void SecurityStatus::set_authenticator_enabled(bool value) {
 set_has_authenticator_enabled();
 authenticator_enabled_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.SecurityStatus.authenticator_enabled)
}
 
// optional bool sqa_enabled = 4;
inline bool SecurityStatus::has_sqa_enabled() const {
 return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void SecurityStatus::set_has_sqa_enabled() {
 _has_bits_[0] |= 0x00000008u;
}
inline void SecurityStatus::clear_has_sqa_enabled() {
 _has_bits_[0] &= ~0x00000008u;
}
inline void SecurityStatus::clear_sqa_enabled() {
 sqa_enabled_ = false;
 clear_has_sqa_enabled();
}
inline bool SecurityStatus::sqa_enabled() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SecurityStatus.sqa_enabled)
 return sqa_enabled_;
}
inline void SecurityStatus::set_sqa_enabled(bool value) {
 set_has_sqa_enabled();
 sqa_enabled_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.SecurityStatus.sqa_enabled)
}
 
// optional bool authenticator_required = 5;
inline bool SecurityStatus::has_authenticator_required() const {
 return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void SecurityStatus::set_has_authenticator_required() {
 _has_bits_[0] |= 0x00000010u;
}
inline void SecurityStatus::clear_has_authenticator_required() {
 _has_bits_[0] &= ~0x00000010u;
}
inline void SecurityStatus::clear_authenticator_required() {
 authenticator_required_ = false;
 clear_has_authenticator_required();
}
inline bool SecurityStatus::authenticator_required() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SecurityStatus.authenticator_required)
 return authenticator_required_;
}
inline void SecurityStatus::set_authenticator_required(bool value) {
 set_has_authenticator_required();
 authenticator_required_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.SecurityStatus.authenticator_required)
}
 
// -------------------------------------------------------------------
 
// 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_;
}
 
// optional .bgs.protocol.account.v1.SecurityStatus security_status = 8;
inline bool AccountState::has_security_status() const {
 return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void AccountState::set_has_security_status() {
 _has_bits_[0] |= 0x00000040u;
}
inline void AccountState::clear_has_security_status() {
 _has_bits_[0] &= ~0x00000040u;
}
inline void AccountState::clear_security_status() {
 if (security_status_ != NULL) security_status_->::bgs::protocol::account::v1::SecurityStatus::Clear();
 clear_has_security_status();
}
inline const ::bgs::protocol::account::v1::SecurityStatus& AccountState::security_status() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountState.security_status)
 return security_status_ != NULL ? *security_status_ : *default_instance_->security_status_;
}
inline ::bgs::protocol::account::v1::SecurityStatus* AccountState::mutable_security_status() {
 set_has_security_status();
 if (security_status_ == NULL) security_status_ = new ::bgs::protocol::account::v1::SecurityStatus;
 // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountState.security_status)
 return security_status_;
}
inline ::bgs::protocol::account::v1::SecurityStatus* AccountState::release_security_status() {
 clear_has_security_status();
 ::bgs::protocol::account::v1::SecurityStatus* temp = security_status_;
 security_status_ = NULL;
 return temp;
}
inline void AccountState::set_allocated_security_status(::bgs::protocol::account::v1::SecurityStatus* security_status) {
 delete security_status_;
 security_status_ = security_status;
 if (security_status) {
 set_has_security_status();
 } else {
 clear_has_security_status();
 }
 // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountState.security_status)
}
 
// optional .bgs.protocol.account.v1.PlayScheduleRestriction government_curfew = 9;
inline bool AccountState::has_government_curfew() const {
 return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void AccountState::set_has_government_curfew() {
 _has_bits_[0] |= 0x00000080u;
}
inline void AccountState::clear_has_government_curfew() {
 _has_bits_[0] &= ~0x00000080u;
}
inline void AccountState::clear_government_curfew() {
 if (government_curfew_ != NULL) government_curfew_->::bgs::protocol::account::v1::PlayScheduleRestriction::Clear();
 clear_has_government_curfew();
}
inline const ::bgs::protocol::account::v1::PlayScheduleRestriction& AccountState::government_curfew() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountState.government_curfew)
 return government_curfew_ != NULL ? *government_curfew_ : *default_instance_->government_curfew_;
}
inline ::bgs::protocol::account::v1::PlayScheduleRestriction* AccountState::mutable_government_curfew() {
 set_has_government_curfew();
 if (government_curfew_ == NULL) government_curfew_ = new ::bgs::protocol::account::v1::PlayScheduleRestriction;
 // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountState.government_curfew)
 return government_curfew_;
}
inline ::bgs::protocol::account::v1::PlayScheduleRestriction* AccountState::release_government_curfew() {
 clear_has_government_curfew();
 ::bgs::protocol::account::v1::PlayScheduleRestriction* temp = government_curfew_;
 government_curfew_ = NULL;
 return temp;
}
inline void AccountState::set_allocated_government_curfew(::bgs::protocol::account::v1::PlayScheduleRestriction* government_curfew) {
 delete government_curfew_;
 government_curfew_ = government_curfew;
 if (government_curfew) {
 set_has_government_curfew();
 } else {
 clear_has_government_curfew();
 }
 // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountState.government_curfew)
}
 
// -------------------------------------------------------------------
 
// 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_;
}
 
// -------------------------------------------------------------------
 
// IgrId
 
// optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1 [deprecated = true];
inline bool IgrId::has_game_account() const {
 return type_case() == kGameAccount;
}
inline void IgrId::set_has_game_account() {
 _oneof_case_[0] = kGameAccount;
}
inline void IgrId::clear_game_account() {
 if (has_game_account()) {
 delete type_.game_account_;
 clear_has_type();
 }
}
inline const ::bgs::protocol::account::v1::GameAccountHandle& IgrId::game_account() const {
 return has_game_account() ? *type_.game_account_
 : ::bgs::protocol::account::v1::GameAccountHandle::default_instance();
}
inline ::bgs::protocol::account::v1::GameAccountHandle* IgrId::mutable_game_account() {
 if (!has_game_account()) {
 clear_type();
 set_has_game_account();
 type_.game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle;
 }
 return type_.game_account_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* IgrId::release_game_account() {
 if (has_game_account()) {
 clear_has_type();
 ::bgs::protocol::account::v1::GameAccountHandle* temp = type_.game_account_;
 type_.game_account_ = NULL;
 return temp;
 } else {
 return NULL;
 }
}
inline void IgrId::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) {
 clear_type();
 if (game_account) {
 set_has_game_account();
 type_.game_account_ = game_account;
 }
}
 
// optional fixed32 external_id = 2;
inline bool IgrId::has_external_id() const {
 return type_case() == kExternalId;
}
inline void IgrId::set_has_external_id() {
 _oneof_case_[0] = kExternalId;
}
inline void IgrId::clear_external_id() {
 if (has_external_id()) {
 type_.external_id_ = 0u;
 clear_has_type();
 }
}
inline ::google::protobuf::uint32 IgrId::external_id() const {
 if (has_external_id()) {
 return type_.external_id_;
 }
 return 0u;
}
inline void IgrId::set_external_id(::google::protobuf::uint32 value) {
 if (!has_external_id()) {
 clear_type();
 set_has_external_id();
 }
 type_.external_id_ = value;
}
 
// optional string uuid = 3;
inline bool IgrId::has_uuid() const {
 return type_case() == kUuid;
}
inline void IgrId::set_has_uuid() {
 _oneof_case_[0] = kUuid;
}
inline void IgrId::clear_uuid() {
 if (has_uuid()) {
 delete type_.uuid_;
 clear_has_type();
 }
}
inline const ::std::string& IgrId::uuid() const {
 if (has_uuid()) {
 return *type_.uuid_;
 }
 return ::google::protobuf::internal::GetEmptyStringAlreadyInited();
}
inline void IgrId::set_uuid(const ::std::string& value) {
 if (!has_uuid()) {
 clear_type();
 set_has_uuid();
 type_.uuid_ = new ::std::string;
 }
 type_.uuid_->assign(value);
}
inline void IgrId::set_uuid(const char* value) {
 if (!has_uuid()) {
 clear_type();
 set_has_uuid();
 type_.uuid_ = new ::std::string;
 }
 type_.uuid_->assign(value);
}
inline void IgrId::set_uuid(const char* value, size_t size) {
 if (!has_uuid()) {
 clear_type();
 set_has_uuid();
 type_.uuid_ = new ::std::string;
 }
 type_.uuid_->assign(
 reinterpret_cast<const char*>(value), size);
}
inline ::std::string* IgrId::mutable_uuid() {
 if (!has_uuid()) {
 clear_type();
 set_has_uuid();
 type_.uuid_ = new ::std::string;
 }
 return type_.uuid_;
}
inline ::std::string* IgrId::release_uuid() {
 if (has_uuid()) {
 clear_has_type();
 ::std::string* temp = type_.uuid_;
 type_.uuid_ = NULL;
 return temp;
 } else {
 return NULL;
 }
}
inline void IgrId::set_allocated_uuid(::std::string* uuid) {
 clear_type();
 if (uuid) {
 set_has_uuid();
 type_.uuid_ = uuid;
 }
}
 
inline bool IgrId::has_type() {
 return type_case() != TYPE_NOT_SET;
}
inline void IgrId::clear_has_type() {
 _oneof_case_[0] = TYPE_NOT_SET;
}
inline IgrId::TypeCase IgrId::type_case() const {
 return IgrId::TypeCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------
 
// IgrAddress
 
// optional string client_address = 1;
inline bool IgrAddress::has_client_address() const {
 return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void IgrAddress::set_has_client_address() {
 _has_bits_[0] |= 0x00000001u;
}
inline void IgrAddress::clear_has_client_address() {
 _has_bits_[0] &= ~0x00000001u;
}
inline void IgrAddress::clear_client_address() {
 if (client_address_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 client_address_->clear();
 }
 clear_has_client_address();
}
inline const ::std::string& IgrAddress::client_address() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.IgrAddress.client_address)
 return *client_address_;
}
inline void IgrAddress::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.IgrAddress.client_address)
}
inline void IgrAddress::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.IgrAddress.client_address)
}
inline void IgrAddress::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.IgrAddress.client_address)
}
inline ::std::string* IgrAddress::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.IgrAddress.client_address)
 return client_address_;
}
inline ::std::string* IgrAddress::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 IgrAddress::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.IgrAddress.client_address)
}
 
// optional uint32 region = 2;
inline bool IgrAddress::has_region() const {
 return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void IgrAddress::set_has_region() {
 _has_bits_[0] |= 0x00000002u;
}
inline void IgrAddress::clear_has_region() {
 _has_bits_[0] &= ~0x00000002u;
}
inline void IgrAddress::clear_region() {
 region_ = 0u;
 clear_has_region();
}
inline ::google::protobuf::uint32 IgrAddress::region() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.IgrAddress.region)
 return region_;
}
inline void IgrAddress::set_region(::google::protobuf::uint32 value) {
 set_has_region();
 region_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.IgrAddress.region)
}
 
// -------------------------------------------------------------------
 
// AccountPrivacySetting
 
// optional bool is_using_rid = 1;
inline bool AccountPrivacySetting::has_is_using_rid() const {
 return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AccountPrivacySetting::set_has_is_using_rid() {
 _has_bits_[0] |= 0x00000001u;
}
inline void AccountPrivacySetting::clear_has_is_using_rid() {
 _has_bits_[0] &= ~0x00000001u;
}
inline void AccountPrivacySetting::clear_is_using_rid() {
 is_using_rid_ = false;
 clear_has_is_using_rid();
}
inline bool AccountPrivacySetting::is_using_rid() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountPrivacySetting.is_using_rid)
 return is_using_rid_;
}
inline void AccountPrivacySetting::set_is_using_rid(bool value) {
 set_has_is_using_rid();
 is_using_rid_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountPrivacySetting.is_using_rid)
}
 
// optional bool is_visible_for_view_friends = 2;
inline bool AccountPrivacySetting::has_is_visible_for_view_friends() const {
 return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void AccountPrivacySetting::set_has_is_visible_for_view_friends() {
 _has_bits_[0] |= 0x00000002u;
}
inline void AccountPrivacySetting::clear_has_is_visible_for_view_friends() {
 _has_bits_[0] &= ~0x00000002u;
}
inline void AccountPrivacySetting::clear_is_visible_for_view_friends() {
 is_visible_for_view_friends_ = false;
 clear_has_is_visible_for_view_friends();
}
inline bool AccountPrivacySetting::is_visible_for_view_friends() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountPrivacySetting.is_visible_for_view_friends)
 return is_visible_for_view_friends_;
}
inline void AccountPrivacySetting::set_is_visible_for_view_friends(bool value) {
 set_has_is_visible_for_view_friends();
 is_visible_for_view_friends_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountPrivacySetting.is_visible_for_view_friends)
}
 
// optional bool is_hidden_from_friend_finder = 3;
inline bool AccountPrivacySetting::has_is_hidden_from_friend_finder() const {
 return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void AccountPrivacySetting::set_has_is_hidden_from_friend_finder() {
 _has_bits_[0] |= 0x00000004u;
}
inline void AccountPrivacySetting::clear_has_is_hidden_from_friend_finder() {
 _has_bits_[0] &= ~0x00000004u;
}
inline void AccountPrivacySetting::clear_is_hidden_from_friend_finder() {
 is_hidden_from_friend_finder_ = false;
 clear_has_is_hidden_from_friend_finder();
}
inline bool AccountPrivacySetting::is_hidden_from_friend_finder() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountPrivacySetting.is_hidden_from_friend_finder)
 return is_hidden_from_friend_finder_;
}
inline void AccountPrivacySetting::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.AccountPrivacySetting.is_hidden_from_friend_finder)
}
 
// optional bool only_allow_friend_whispers = 4;
inline bool AccountPrivacySetting::has_only_allow_friend_whispers() const {
 return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void AccountPrivacySetting::set_has_only_allow_friend_whispers() {
 _has_bits_[0] |= 0x00000008u;
}
inline void AccountPrivacySetting::clear_has_only_allow_friend_whispers() {
 _has_bits_[0] &= ~0x00000008u;
}
inline void AccountPrivacySetting::clear_only_allow_friend_whispers() {
 only_allow_friend_whispers_ = false;
 clear_has_only_allow_friend_whispers();
}
inline bool AccountPrivacySetting::only_allow_friend_whispers() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountPrivacySetting.only_allow_friend_whispers)
 return only_allow_friend_whispers_;
}
inline void AccountPrivacySetting::set_only_allow_friend_whispers(bool value) {
 set_has_only_allow_friend_whispers();
 only_allow_friend_whispers_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountPrivacySetting.only_allow_friend_whispers)
}
 
// -------------------------------------------------------------------
 
// AccountInfo
 
// optional string battle_tag = 1;
inline bool AccountInfo::has_battle_tag() const {
 return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AccountInfo::set_has_battle_tag() {
 _has_bits_[0] |= 0x00000001u;
}
inline void AccountInfo::clear_has_battle_tag() {
 _has_bits_[0] &= ~0x00000001u;
}
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.account.v1.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.account.v1.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.account.v1.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.account.v1.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.account.v1.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.account.v1.AccountInfo.battle_tag)
}
 
// optional string email = 2;
inline bool AccountInfo::has_email() const {
 return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void AccountInfo::set_has_email() {
 _has_bits_[0] |= 0x00000002u;
}
inline void AccountInfo::clear_has_email() {
 _has_bits_[0] &= ~0x00000002u;
}
inline void AccountInfo::clear_email() {
 if (email_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 email_->clear();
 }
 clear_has_email();
}
inline const ::std::string& AccountInfo::email() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.email)
 return *email_;
}
inline void AccountInfo::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.AccountInfo.email)
}
inline void AccountInfo::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.AccountInfo.email)
}
inline void AccountInfo::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.AccountInfo.email)
}
inline ::std::string* AccountInfo::mutable_email() {
 set_has_email();
 if (email_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 email_ = new ::std::string;
 }
 // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountInfo.email)
 return email_;
}
inline ::std::string* AccountInfo::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 AccountInfo::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.AccountInfo.email)
}
 
// optional string phone_number = 3;
inline bool AccountInfo::has_phone_number() const {
 return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void AccountInfo::set_has_phone_number() {
 _has_bits_[0] |= 0x00000004u;
}
inline void AccountInfo::clear_has_phone_number() {
 _has_bits_[0] &= ~0x00000004u;
}
inline void AccountInfo::clear_phone_number() {
 if (phone_number_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 phone_number_->clear();
 }
 clear_has_phone_number();
}
inline const ::std::string& AccountInfo::phone_number() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.phone_number)
 return *phone_number_;
}
inline void AccountInfo::set_phone_number(const ::std::string& value) {
 set_has_phone_number();
 if (phone_number_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 phone_number_ = new ::std::string;
 }
 phone_number_->assign(value);
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountInfo.phone_number)
}
inline void AccountInfo::set_phone_number(const char* value) {
 set_has_phone_number();
 if (phone_number_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 phone_number_ = new ::std::string;
 }
 phone_number_->assign(value);
 // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountInfo.phone_number)
}
inline void AccountInfo::set_phone_number(const char* value, size_t size) {
 set_has_phone_number();
 if (phone_number_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 phone_number_ = new ::std::string;
 }
 phone_number_->assign(reinterpret_cast<const char*>(value), size);
 // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountInfo.phone_number)
}
inline ::std::string* AccountInfo::mutable_phone_number() {
 set_has_phone_number();
 if (phone_number_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 phone_number_ = new ::std::string;
 }
 // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountInfo.phone_number)
 return phone_number_;
}
inline ::std::string* AccountInfo::release_phone_number() {
 clear_has_phone_number();
 if (phone_number_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 return NULL;
 } else {
 ::std::string* temp = phone_number_;
 phone_number_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 return temp;
 }
}
inline void AccountInfo::set_allocated_phone_number(::std::string* phone_number) {
 if (phone_number_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 delete phone_number_;
 }
 if (phone_number) {
 set_has_phone_number();
 phone_number_ = phone_number;
 } else {
 clear_has_phone_number();
 phone_number_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 }
 // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountInfo.phone_number)
}
 
// optional string full_name = 4;
inline bool AccountInfo::has_full_name() const {
 return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void AccountInfo::set_has_full_name() {
 _has_bits_[0] |= 0x00000008u;
}
inline void AccountInfo::clear_has_full_name() {
 _has_bits_[0] &= ~0x00000008u;
}
inline void AccountInfo::clear_full_name() {
 if (full_name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 full_name_->clear();
 }
 clear_has_full_name();
}
inline const ::std::string& AccountInfo::full_name() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.full_name)
 return *full_name_;
}
inline void AccountInfo::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.AccountInfo.full_name)
}
inline void AccountInfo::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.AccountInfo.full_name)
}
inline void AccountInfo::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.AccountInfo.full_name)
}
inline ::std::string* AccountInfo::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.AccountInfo.full_name)
 return full_name_;
}
inline ::std::string* AccountInfo::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 AccountInfo::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.AccountInfo.full_name)
}
 
// optional string birthdate = 5;
inline bool AccountInfo::has_birthdate() const {
 return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void AccountInfo::set_has_birthdate() {
 _has_bits_[0] |= 0x00000010u;
}
inline void AccountInfo::clear_has_birthdate() {
 _has_bits_[0] &= ~0x00000010u;
}
inline void AccountInfo::clear_birthdate() {
 if (birthdate_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 birthdate_->clear();
 }
 clear_has_birthdate();
}
inline const ::std::string& AccountInfo::birthdate() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.birthdate)
 return *birthdate_;
}
inline void AccountInfo::set_birthdate(const ::std::string& value) {
 set_has_birthdate();
 if (birthdate_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 birthdate_ = new ::std::string;
 }
 birthdate_->assign(value);
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountInfo.birthdate)
}
inline void AccountInfo::set_birthdate(const char* value) {
 set_has_birthdate();
 if (birthdate_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 birthdate_ = new ::std::string;
 }
 birthdate_->assign(value);
 // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountInfo.birthdate)
}
inline void AccountInfo::set_birthdate(const char* value, size_t size) {
 set_has_birthdate();
 if (birthdate_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 birthdate_ = new ::std::string;
 }
 birthdate_->assign(reinterpret_cast<const char*>(value), size);
 // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountInfo.birthdate)
}
inline ::std::string* AccountInfo::mutable_birthdate() {
 set_has_birthdate();
 if (birthdate_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 birthdate_ = new ::std::string;
 }
 // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountInfo.birthdate)
 return birthdate_;
}
inline ::std::string* AccountInfo::release_birthdate() {
 clear_has_birthdate();
 if (birthdate_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 return NULL;
 } else {
 ::std::string* temp = birthdate_;
 birthdate_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 return temp;
 }
}
inline void AccountInfo::set_allocated_birthdate(::std::string* birthdate) {
 if (birthdate_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 delete birthdate_;
 }
 if (birthdate) {
 set_has_birthdate();
 birthdate_ = birthdate;
 } else {
 clear_has_birthdate();
 birthdate_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 }
 // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountInfo.birthdate)
}
 
// optional string country = 6;
inline bool AccountInfo::has_country() const {
 return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void AccountInfo::set_has_country() {
 _has_bits_[0] |= 0x00000020u;
}
inline void AccountInfo::clear_has_country() {
 _has_bits_[0] &= ~0x00000020u;
}
inline void AccountInfo::clear_country() {
 if (country_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 country_->clear();
 }
 clear_has_country();
}
inline const ::std::string& AccountInfo::country() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.country)
 return *country_;
}
inline void AccountInfo::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.AccountInfo.country)
}
inline void AccountInfo::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.AccountInfo.country)
}
inline void AccountInfo::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.AccountInfo.country)
}
inline ::std::string* AccountInfo::mutable_country() {
 set_has_country();
 if (country_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 country_ = new ::std::string;
 }
 // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountInfo.country)
 return country_;
}
inline ::std::string* AccountInfo::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 AccountInfo::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.AccountInfo.country)
}
 
// optional string default_currency = 7;
inline bool AccountInfo::has_default_currency() const {
 return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void AccountInfo::set_has_default_currency() {
 _has_bits_[0] |= 0x00000040u;
}
inline void AccountInfo::clear_has_default_currency() {
 _has_bits_[0] &= ~0x00000040u;
}
inline void AccountInfo::clear_default_currency() {
 if (default_currency_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 default_currency_->clear();
 }
 clear_has_default_currency();
}
inline const ::std::string& AccountInfo::default_currency() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.default_currency)
 return *default_currency_;
}
inline void AccountInfo::set_default_currency(const ::std::string& value) {
 set_has_default_currency();
 if (default_currency_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 default_currency_ = new ::std::string;
 }
 default_currency_->assign(value);
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountInfo.default_currency)
}
inline void AccountInfo::set_default_currency(const char* value) {
 set_has_default_currency();
 if (default_currency_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 default_currency_ = new ::std::string;
 }
 default_currency_->assign(value);
 // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.AccountInfo.default_currency)
}
inline void AccountInfo::set_default_currency(const char* value, size_t size) {
 set_has_default_currency();
 if (default_currency_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 default_currency_ = new ::std::string;
 }
 default_currency_->assign(reinterpret_cast<const char*>(value), size);
 // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.AccountInfo.default_currency)
}
inline ::std::string* AccountInfo::mutable_default_currency() {
 set_has_default_currency();
 if (default_currency_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 default_currency_ = new ::std::string;
 }
 // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountInfo.default_currency)
 return default_currency_;
}
inline ::std::string* AccountInfo::release_default_currency() {
 clear_has_default_currency();
 if (default_currency_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 return NULL;
 } else {
 ::std::string* temp = default_currency_;
 default_currency_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 return temp;
 }
}
inline void AccountInfo::set_allocated_default_currency(::std::string* default_currency) {
 if (default_currency_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
 delete default_currency_;
 }
 if (default_currency) {
 set_has_default_currency();
 default_currency_ = default_currency;
 } else {
 clear_has_default_currency();
 default_currency_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
 }
 // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountInfo.default_currency)
}
 
// optional uint32 preferred_region = 8;
inline bool AccountInfo::has_preferred_region() const {
 return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void AccountInfo::set_has_preferred_region() {
 _has_bits_[0] |= 0x00000080u;
}
inline void AccountInfo::clear_has_preferred_region() {
 _has_bits_[0] &= ~0x00000080u;
}
inline void AccountInfo::clear_preferred_region() {
 preferred_region_ = 0u;
 clear_has_preferred_region();
}
inline ::google::protobuf::uint32 AccountInfo::preferred_region() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.preferred_region)
 return preferred_region_;
}
inline void AccountInfo::set_preferred_region(::google::protobuf::uint32 value) {
 set_has_preferred_region();
 preferred_region_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountInfo.preferred_region)
}
 
// optional uint32 ratings_board_minimum_age = 9;
inline bool AccountInfo::has_ratings_board_minimum_age() const {
 return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void AccountInfo::set_has_ratings_board_minimum_age() {
 _has_bits_[0] |= 0x00000100u;
}
inline void AccountInfo::clear_has_ratings_board_minimum_age() {
 _has_bits_[0] &= ~0x00000100u;
}
inline void AccountInfo::clear_ratings_board_minimum_age() {
 ratings_board_minimum_age_ = 0u;
 clear_has_ratings_board_minimum_age();
}
inline ::google::protobuf::uint32 AccountInfo::ratings_board_minimum_age() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.ratings_board_minimum_age)
 return ratings_board_minimum_age_;
}
inline void AccountInfo::set_ratings_board_minimum_age(::google::protobuf::uint32 value) {
 set_has_ratings_board_minimum_age();
 ratings_board_minimum_age_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountInfo.ratings_board_minimum_age)
}
 
// optional bool has_parental_control = 10;
inline bool AccountInfo::has_has_parental_control() const {
 return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void AccountInfo::set_has_has_parental_control() {
 _has_bits_[0] |= 0x00000200u;
}
inline void AccountInfo::clear_has_has_parental_control() {
 _has_bits_[0] &= ~0x00000200u;
}
inline void AccountInfo::clear_has_parental_control() {
 has_parental_control_ = false;
 clear_has_has_parental_control();
}
inline bool AccountInfo::has_parental_control() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.has_parental_control)
 return has_parental_control_;
}
inline void AccountInfo::set_has_parental_control(bool value) {
 set_has_has_parental_control();
 has_parental_control_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountInfo.has_parental_control)
}
 
// optional bool is_email_verified = 11;
inline bool AccountInfo::has_is_email_verified() const {
 return (_has_bits_[0] & 0x00000400u) != 0;
}
inline void AccountInfo::set_has_is_email_verified() {
 _has_bits_[0] |= 0x00000400u;
}
inline void AccountInfo::clear_has_is_email_verified() {
 _has_bits_[0] &= ~0x00000400u;
}
inline void AccountInfo::clear_is_email_verified() {
 is_email_verified_ = false;
 clear_has_is_email_verified();
}
inline bool AccountInfo::is_email_verified() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.is_email_verified)
 return is_email_verified_;
}
inline void AccountInfo::set_is_email_verified(bool value) {
 set_has_is_email_verified();
 is_email_verified_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountInfo.is_email_verified)
}
 
// optional bool is_sms_protected = 12;
inline bool AccountInfo::has_is_sms_protected() const {
 return (_has_bits_[0] & 0x00000800u) != 0;
}
inline void AccountInfo::set_has_is_sms_protected() {
 _has_bits_[0] |= 0x00000800u;
}
inline void AccountInfo::clear_has_is_sms_protected() {
 _has_bits_[0] &= ~0x00000800u;
}
inline void AccountInfo::clear_is_sms_protected() {
 is_sms_protected_ = false;
 clear_has_is_sms_protected();
}
inline bool AccountInfo::is_sms_protected() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.is_sms_protected)
 return is_sms_protected_;
}
inline void AccountInfo::set_is_sms_protected(bool value) {
 set_has_is_sms_protected();
 is_sms_protected_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountInfo.is_sms_protected)
}
 
// optional bool is_headless_account = 13;
inline bool AccountInfo::has_is_headless_account() const {
 return (_has_bits_[0] & 0x00001000u) != 0;
}
inline void AccountInfo::set_has_is_headless_account() {
 _has_bits_[0] |= 0x00001000u;
}
inline void AccountInfo::clear_has_is_headless_account() {
 _has_bits_[0] &= ~0x00001000u;
}
inline void AccountInfo::clear_is_headless_account() {
 is_headless_account_ = false;
 clear_has_is_headless_account();
}
inline bool AccountInfo::is_headless_account() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.is_headless_account)
 return is_headless_account_;
}
inline void AccountInfo::set_is_headless_account(bool value) {
 set_has_is_headless_account();
 is_headless_account_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountInfo.is_headless_account)
}
 
// optional bool is_employee = 14;
inline bool AccountInfo::has_is_employee() const {
 return (_has_bits_[0] & 0x00002000u) != 0;
}
inline void AccountInfo::set_has_is_employee() {
 _has_bits_[0] |= 0x00002000u;
}
inline void AccountInfo::clear_has_is_employee() {
 _has_bits_[0] &= ~0x00002000u;
}
inline void AccountInfo::clear_is_employee() {
 is_employee_ = false;
 clear_has_is_employee();
}
inline bool AccountInfo::is_employee() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.is_employee)
 return is_employee_;
}
inline void AccountInfo::set_is_employee(bool value) {
 set_has_is_employee();
 is_employee_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountInfo.is_employee)
}
 
// optional bool is_test_account = 15;
inline bool AccountInfo::has_is_test_account() const {
 return (_has_bits_[0] & 0x00004000u) != 0;
}
inline void AccountInfo::set_has_is_test_account() {
 _has_bits_[0] |= 0x00004000u;
}
inline void AccountInfo::clear_has_is_test_account() {
 _has_bits_[0] &= ~0x00004000u;
}
inline void AccountInfo::clear_is_test_account() {
 is_test_account_ = false;
 clear_has_is_test_account();
}
inline bool AccountInfo::is_test_account() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.is_test_account)
 return is_test_account_;
}
inline void AccountInfo::set_is_test_account(bool value) {
 set_has_is_test_account();
 is_test_account_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountInfo.is_test_account)
}
 
// optional .bgs.protocol.account.v1.AccountPrivacySetting privacy_setting = 16;
inline bool AccountInfo::has_privacy_setting() const {
 return (_has_bits_[0] & 0x00008000u) != 0;
}
inline void AccountInfo::set_has_privacy_setting() {
 _has_bits_[0] |= 0x00008000u;
}
inline void AccountInfo::clear_has_privacy_setting() {
 _has_bits_[0] &= ~0x00008000u;
}
inline void AccountInfo::clear_privacy_setting() {
 if (privacy_setting_ != NULL) privacy_setting_->::bgs::protocol::account::v1::AccountPrivacySetting::Clear();
 clear_has_privacy_setting();
}
inline const ::bgs::protocol::account::v1::AccountPrivacySetting& AccountInfo::privacy_setting() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountInfo.privacy_setting)
 return privacy_setting_ != NULL ? *privacy_setting_ : *default_instance_->privacy_setting_;
}
inline ::bgs::protocol::account::v1::AccountPrivacySetting* AccountInfo::mutable_privacy_setting() {
 set_has_privacy_setting();
 if (privacy_setting_ == NULL) privacy_setting_ = new ::bgs::protocol::account::v1::AccountPrivacySetting;
 // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountInfo.privacy_setting)
 return privacy_setting_;
}
inline ::bgs::protocol::account::v1::AccountPrivacySetting* AccountInfo::release_privacy_setting() {
 clear_has_privacy_setting();
 ::bgs::protocol::account::v1::AccountPrivacySetting* temp = privacy_setting_;
 privacy_setting_ = NULL;
 return temp;
}
inline void AccountInfo::set_allocated_privacy_setting(::bgs::protocol::account::v1::AccountPrivacySetting* privacy_setting) {
 delete privacy_setting_;
 privacy_setting_ = privacy_setting;
 if (privacy_setting) {
 set_has_privacy_setting();
 } else {
 clear_has_privacy_setting();
 }
 // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountInfo.privacy_setting)
}
 
// -------------------------------------------------------------------
 
// RestrictionStatus
 
// optional bool active = 1;
inline bool RestrictionStatus::has_active() const {
 return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RestrictionStatus::set_has_active() {
 _has_bits_[0] |= 0x00000001u;
}
inline void RestrictionStatus::clear_has_active() {
 _has_bits_[0] &= ~0x00000001u;
}
inline void RestrictionStatus::clear_active() {
 active_ = false;
 clear_has_active();
}
inline bool RestrictionStatus::active() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.RestrictionStatus.active)
 return active_;
}
inline void RestrictionStatus::set_active(bool value) {
 set_has_active();
 active_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.RestrictionStatus.active)
}
 
// optional uint64 expiration_us = 2;
inline bool RestrictionStatus::has_expiration_us() const {
 return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RestrictionStatus::set_has_expiration_us() {
 _has_bits_[0] |= 0x00000002u;
}
inline void RestrictionStatus::clear_has_expiration_us() {
 _has_bits_[0] &= ~0x00000002u;
}
inline void RestrictionStatus::clear_expiration_us() {
 expiration_us_ = GOOGLE_ULONGLONG(0);
 clear_has_expiration_us();
}
inline ::google::protobuf::uint64 RestrictionStatus::expiration_us() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.RestrictionStatus.expiration_us)
 return expiration_us_;
}
inline void RestrictionStatus::set_expiration_us(::google::protobuf::uint64 value) {
 set_has_expiration_us();
 expiration_us_ = value;
 // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.RestrictionStatus.expiration_us)
}
 
// -------------------------------------------------------------------
 
// AccountPlatformRestrictionInfo
 
// optional .bgs.protocol.account.v1.RestrictionStatus squelched = 2;
inline bool AccountPlatformRestrictionInfo::has_squelched() const {
 return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AccountPlatformRestrictionInfo::set_has_squelched() {
 _has_bits_[0] |= 0x00000001u;
}
inline void AccountPlatformRestrictionInfo::clear_has_squelched() {
 _has_bits_[0] &= ~0x00000001u;
}
inline void AccountPlatformRestrictionInfo::clear_squelched() {
 if (squelched_ != NULL) squelched_->::bgs::protocol::account::v1::RestrictionStatus::Clear();
 clear_has_squelched();
}
inline const ::bgs::protocol::account::v1::RestrictionStatus& AccountPlatformRestrictionInfo::squelched() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountPlatformRestrictionInfo.squelched)
 return squelched_ != NULL ? *squelched_ : *default_instance_->squelched_;
}
inline ::bgs::protocol::account::v1::RestrictionStatus* AccountPlatformRestrictionInfo::mutable_squelched() {
 set_has_squelched();
 if (squelched_ == NULL) squelched_ = new ::bgs::protocol::account::v1::RestrictionStatus;
 // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountPlatformRestrictionInfo.squelched)
 return squelched_;
}
inline ::bgs::protocol::account::v1::RestrictionStatus* AccountPlatformRestrictionInfo::release_squelched() {
 clear_has_squelched();
 ::bgs::protocol::account::v1::RestrictionStatus* temp = squelched_;
 squelched_ = NULL;
 return temp;
}
inline void AccountPlatformRestrictionInfo::set_allocated_squelched(::bgs::protocol::account::v1::RestrictionStatus* squelched) {
 delete squelched_;
 squelched_ = squelched;
 if (squelched) {
 set_has_squelched();
 } else {
 clear_has_squelched();
 }
 // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountPlatformRestrictionInfo.squelched)
}
 
// optional .bgs.protocol.account.v1.RestrictionStatus legal_country_feature_restrictions_applied = 3;
inline bool AccountPlatformRestrictionInfo::has_legal_country_feature_restrictions_applied() const {
 return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void AccountPlatformRestrictionInfo::set_has_legal_country_feature_restrictions_applied() {
 _has_bits_[0] |= 0x00000002u;
}
inline void AccountPlatformRestrictionInfo::clear_has_legal_country_feature_restrictions_applied() {
 _has_bits_[0] &= ~0x00000002u;
}
inline void AccountPlatformRestrictionInfo::clear_legal_country_feature_restrictions_applied() {
 if (legal_country_feature_restrictions_applied_ != NULL) legal_country_feature_restrictions_applied_->::bgs::protocol::account::v1::RestrictionStatus::Clear();
 clear_has_legal_country_feature_restrictions_applied();
}
inline const ::bgs::protocol::account::v1::RestrictionStatus& AccountPlatformRestrictionInfo::legal_country_feature_restrictions_applied() const {
 // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountPlatformRestrictionInfo.legal_country_feature_restrictions_applied)
 return legal_country_feature_restrictions_applied_ != NULL ? *legal_country_feature_restrictions_applied_ : *default_instance_->legal_country_feature_restrictions_applied_;
}
inline ::bgs::protocol::account::v1::RestrictionStatus* AccountPlatformRestrictionInfo::mutable_legal_country_feature_restrictions_applied() {
 set_has_legal_country_feature_restrictions_applied();
 if (legal_country_feature_restrictions_applied_ == NULL) legal_country_feature_restrictions_applied_ = new ::bgs::protocol::account::v1::RestrictionStatus;
 // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountPlatformRestrictionInfo.legal_country_feature_restrictions_applied)
 return legal_country_feature_restrictions_applied_;
}
inline ::bgs::protocol::account::v1::RestrictionStatus* AccountPlatformRestrictionInfo::release_legal_country_feature_restrictions_applied() {
 clear_has_legal_country_feature_restrictions_applied();
 ::bgs::protocol::account::v1::RestrictionStatus* temp = legal_country_feature_restrictions_applied_;
 legal_country_feature_restrictions_applied_ = NULL;
 return temp;
}
inline void AccountPlatformRestrictionInfo::set_allocated_legal_country_feature_restrictions_applied(::bgs::protocol::account::v1::RestrictionStatus* legal_country_feature_restrictions_applied) {
 delete legal_country_feature_restrictions_applied_;
 legal_country_feature_restrictions_applied_ = legal_country_feature_restrictions_applied;
 if (legal_country_feature_restrictions_applied) {
 set_has_legal_country_feature_restrictions_applied();
 } else {
 clear_has_legal_country_feature_restrictions_applied();
 }
 // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountPlatformRestrictionInfo.legal_country_feature_restrictions_applied)
}
 
// @@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