account_service.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: account_service.proto
 
#ifndef PROTOBUF_account_5fservice_2eproto__INCLUDED
#define PROTOBUF_account_5fservice_2eproto__INCLUDED
 
#include <string>
 
#include <google/protobuf/stubs/common.h>
 
#if GOOGLE_PROTOBUF_VERSION < 2006000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif
 
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/unknown_field_set.h>
#include "account_types.pb.h"
#include "entity_types.pb.h"
#include "rpc_types.pb.h"
#include "ServiceBase.h"
#include "MessageBuffer.h"
#include <functional>
#include <type_traits>
// @@protoc_insertion_point(includes)
 
namespace bgs {
namespace protocol {
namespace account {
namespace v1 {
 
// Internal implementation detail -- do not call these.
void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
void protobuf_AssignDesc_account_5fservice_2eproto();
void protobuf_ShutdownFile_account_5fservice_2eproto();
 
class ResolveAccountRequest;
class ResolveAccountResponse;
class GameAccountFlagUpdateRequest;
class SubscriptionUpdateRequest;
class SubscriptionUpdateResponse;
class GetAccountStateRequest;
class GetAccountStateResponse;
class GetSignedAccountStateRequest;
class GetSignedAccountStateResponse;
class GetGameAccountStateRequest;
class GetGameAccountStateResponse;
class GetLicensesRequest;
class GetLicensesResponse;
class GetGameSessionInfoRequest;
class GetGameSessionInfoResponse;
class GetGameTimeRemainingInfoRequest;
class GetGameTimeRemainingInfoResponse;
class GetCAISInfoRequest;
class GetCAISInfoResponse;
class GetAuthorizedDataRequest;
class GetAuthorizedDataResponse;
class GetAccountInfoRequest;
class GetAccountInfoResponse;
class GetAccountPlatformRestrictionsRequest;
class GetAccountPlatformRestrictionsResponse;
class AccountStateNotification;
class GameAccountStateNotification;
class GameAccountNotification;
class GameAccountSessionNotification;
 
// ===================================================================
 
class TC_PROTO_API ResolveAccountRequest : public ::google::protobuf::Message {
 public:
  ResolveAccountRequest();
  virtual ~ResolveAccountRequest();
 
  ResolveAccountRequest(const ResolveAccountRequest& from);
 
  inline ResolveAccountRequest& operator=(const ResolveAccountRequest& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const ResolveAccountRequest& default_instance();
 
  void Swap(ResolveAccountRequest* other);
 
  // implements Message ----------------------------------------------
 
  ResolveAccountRequest* 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.AccountReference ref = 1;
  inline bool has_ref() const;
  inline void clear_ref();
  static const int kRefFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::AccountReference& ref() const;
  inline ::bgs::protocol::account::v1::AccountReference* mutable_ref();
  inline ::bgs::protocol::account::v1::AccountReference* release_ref();
  inline void set_allocated_ref(::bgs::protocol::account::v1::AccountReference* ref);
 
  // optional bool fetch_id = 12;
  inline bool has_fetch_id() const;
  inline void clear_fetch_id();
  static const int kFetchIdFieldNumber = 12;
  inline bool fetch_id() const;
  inline void set_fetch_id(bool value);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.ResolveAccountRequest)
 private:
  inline void set_has_ref();
  inline void clear_has_ref();
  inline void set_has_fetch_id();
  inline void clear_has_fetch_id();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::AccountReference* ref_;
  bool fetch_id_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static ResolveAccountRequest* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API ResolveAccountResponse : public ::google::protobuf::Message {
 public:
  ResolveAccountResponse();
  virtual ~ResolveAccountResponse();
 
  ResolveAccountResponse(const ResolveAccountResponse& from);
 
  inline ResolveAccountResponse& operator=(const ResolveAccountResponse& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const ResolveAccountResponse& default_instance();
 
  void Swap(ResolveAccountResponse* other);
 
  // implements Message ----------------------------------------------
 
  ResolveAccountResponse* 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 id = 12;
  inline bool has_id() const;
  inline void clear_id();
  static const int kIdFieldNumber = 12;
  inline const ::bgs::protocol::account::v1::AccountId& id() const;
  inline ::bgs::protocol::account::v1::AccountId* mutable_id();
  inline ::bgs::protocol::account::v1::AccountId* release_id();
  inline void set_allocated_id(::bgs::protocol::account::v1::AccountId* id);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.ResolveAccountResponse)
 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_;
  ::bgs::protocol::account::v1::AccountId* id_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static ResolveAccountResponse* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GameAccountFlagUpdateRequest : public ::google::protobuf::Message {
 public:
  GameAccountFlagUpdateRequest();
  virtual ~GameAccountFlagUpdateRequest();
 
  GameAccountFlagUpdateRequest(const GameAccountFlagUpdateRequest& from);
 
  inline GameAccountFlagUpdateRequest& operator=(const GameAccountFlagUpdateRequest& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GameAccountFlagUpdateRequest& default_instance();
 
  void Swap(GameAccountFlagUpdateRequest* other);
 
  // implements Message ----------------------------------------------
 
  GameAccountFlagUpdateRequest* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
  inline bool has_game_account() const;
  inline void clear_game_account();
  static const int kGameAccountFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const;
  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account();
  inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account();
  inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account);
 
  // optional uint64 flag = 2;
  inline bool has_flag() const;
  inline void clear_flag();
  static const int kFlagFieldNumber = 2;
  inline ::google::protobuf::uint64 flag() const;
  inline void set_flag(::google::protobuf::uint64 value);
 
  // optional bool active = 3;
  inline bool has_active() const;
  inline void clear_active();
  static const int kActiveFieldNumber = 3;
  inline bool active() const;
  inline void set_active(bool value);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountFlagUpdateRequest)
 private:
  inline void set_has_game_account();
  inline void clear_has_game_account();
  inline void set_has_flag();
  inline void clear_has_flag();
  inline void set_has_active();
  inline void clear_has_active();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
  ::google::protobuf::uint64 flag_;
  bool active_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GameAccountFlagUpdateRequest* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API SubscriptionUpdateRequest : public ::google::protobuf::Message {
 public:
  SubscriptionUpdateRequest();
  virtual ~SubscriptionUpdateRequest();
 
  SubscriptionUpdateRequest(const SubscriptionUpdateRequest& from);
 
  inline SubscriptionUpdateRequest& operator=(const SubscriptionUpdateRequest& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const SubscriptionUpdateRequest& default_instance();
 
  void Swap(SubscriptionUpdateRequest* other);
 
  // implements Message ----------------------------------------------
 
  SubscriptionUpdateRequest* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // repeated .bgs.protocol.account.v1.SubscriberReference ref = 2;
  inline int ref_size() const;
  inline void clear_ref();
  static const int kRefFieldNumber = 2;
  inline const ::bgs::protocol::account::v1::SubscriberReference& ref(int index) const;
  inline ::bgs::protocol::account::v1::SubscriberReference* mutable_ref(int index);
  inline ::bgs::protocol::account::v1::SubscriberReference* add_ref();
  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >&
      ref() const;
  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >*
      mutable_ref();
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.SubscriptionUpdateRequest)
 private:
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference > ref_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static SubscriptionUpdateRequest* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API SubscriptionUpdateResponse : public ::google::protobuf::Message {
 public:
  SubscriptionUpdateResponse();
  virtual ~SubscriptionUpdateResponse();
 
  SubscriptionUpdateResponse(const SubscriptionUpdateResponse& from);
 
  inline SubscriptionUpdateResponse& operator=(const SubscriptionUpdateResponse& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const SubscriptionUpdateResponse& default_instance();
 
  void Swap(SubscriptionUpdateResponse* other);
 
  // implements Message ----------------------------------------------
 
  SubscriptionUpdateResponse* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // repeated .bgs.protocol.account.v1.SubscriberReference ref = 1;
  inline int ref_size() const;
  inline void clear_ref();
  static const int kRefFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::SubscriberReference& ref(int index) const;
  inline ::bgs::protocol::account::v1::SubscriberReference* mutable_ref(int index);
  inline ::bgs::protocol::account::v1::SubscriberReference* add_ref();
  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >&
      ref() const;
  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >*
      mutable_ref();
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.SubscriptionUpdateResponse)
 private:
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference > ref_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static SubscriptionUpdateResponse* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetAccountStateRequest : public ::google::protobuf::Message {
 public:
  GetAccountStateRequest();
  virtual ~GetAccountStateRequest();
 
  GetAccountStateRequest(const GetAccountStateRequest& from);
 
  inline GetAccountStateRequest& operator=(const GetAccountStateRequest& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetAccountStateRequest& default_instance();
 
  void Swap(GetAccountStateRequest* other);
 
  // implements Message ----------------------------------------------
 
  GetAccountStateRequest* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.EntityId entity_id = 1;
  inline bool has_entity_id() const;
  inline void clear_entity_id();
  static const int kEntityIdFieldNumber = 1;
  inline const ::bgs::protocol::EntityId& entity_id() const;
  inline ::bgs::protocol::EntityId* mutable_entity_id();
  inline ::bgs::protocol::EntityId* release_entity_id();
  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
 
  // optional uint32 program = 2;
  inline bool has_program() const;
  inline void clear_program();
  static const int kProgramFieldNumber = 2;
  inline ::google::protobuf::uint32 program() const;
  inline void set_program(::google::protobuf::uint32 value);
 
  // optional uint32 region = 3;
  inline bool has_region() const;
  inline void clear_region();
  static const int kRegionFieldNumber = 3;
  inline ::google::protobuf::uint32 region() const;
  inline void set_region(::google::protobuf::uint32 value);
 
  // optional .bgs.protocol.account.v1.AccountFieldOptions options = 10;
  inline bool has_options() const;
  inline void clear_options();
  static const int kOptionsFieldNumber = 10;
  inline const ::bgs::protocol::account::v1::AccountFieldOptions& options() const;
  inline ::bgs::protocol::account::v1::AccountFieldOptions* mutable_options();
  inline ::bgs::protocol::account::v1::AccountFieldOptions* release_options();
  inline void set_allocated_options(::bgs::protocol::account::v1::AccountFieldOptions* options);
 
  // optional .bgs.protocol.account.v1.AccountFieldTags tags = 11;
  inline bool has_tags() const;
  inline void clear_tags();
  static const int kTagsFieldNumber = 11;
  inline const ::bgs::protocol::account::v1::AccountFieldTags& tags() const;
  inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_tags();
  inline ::bgs::protocol::account::v1::AccountFieldTags* release_tags();
  inline void set_allocated_tags(::bgs::protocol::account::v1::AccountFieldTags* tags);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountStateRequest)
 private:
  inline void set_has_entity_id();
  inline void clear_has_entity_id();
  inline void set_has_program();
  inline void clear_has_program();
  inline void set_has_region();
  inline void clear_has_region();
  inline void set_has_options();
  inline void clear_has_options();
  inline void set_has_tags();
  inline void clear_has_tags();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::EntityId* entity_id_;
  ::google::protobuf::uint32 program_;
  ::google::protobuf::uint32 region_;
  ::bgs::protocol::account::v1::AccountFieldOptions* options_;
  ::bgs::protocol::account::v1::AccountFieldTags* tags_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetAccountStateRequest* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetAccountStateResponse : public ::google::protobuf::Message {
 public:
  GetAccountStateResponse();
  virtual ~GetAccountStateResponse();
 
  GetAccountStateResponse(const GetAccountStateResponse& from);
 
  inline GetAccountStateResponse& operator=(const GetAccountStateResponse& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetAccountStateResponse& default_instance();
 
  void Swap(GetAccountStateResponse* other);
 
  // implements Message ----------------------------------------------
 
  GetAccountStateResponse* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.account.v1.AccountState state = 1;
  inline bool has_state() const;
  inline void clear_state();
  static const int kStateFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::AccountState& state() const;
  inline ::bgs::protocol::account::v1::AccountState* mutable_state();
  inline ::bgs::protocol::account::v1::AccountState* release_state();
  inline void set_allocated_state(::bgs::protocol::account::v1::AccountState* state);
 
  // optional .bgs.protocol.account.v1.AccountFieldTags tags = 2;
  inline bool has_tags() const;
  inline void clear_tags();
  static const int kTagsFieldNumber = 2;
  inline const ::bgs::protocol::account::v1::AccountFieldTags& tags() const;
  inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_tags();
  inline ::bgs::protocol::account::v1::AccountFieldTags* release_tags();
  inline void set_allocated_tags(::bgs::protocol::account::v1::AccountFieldTags* tags);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountStateResponse)
 private:
  inline void set_has_state();
  inline void clear_has_state();
  inline void set_has_tags();
  inline void clear_has_tags();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::AccountState* state_;
  ::bgs::protocol::account::v1::AccountFieldTags* tags_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetAccountStateResponse* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetSignedAccountStateRequest : public ::google::protobuf::Message {
 public:
  GetSignedAccountStateRequest();
  virtual ~GetSignedAccountStateRequest();
 
  GetSignedAccountStateRequest(const GetSignedAccountStateRequest& from);
 
  inline GetSignedAccountStateRequest& operator=(const GetSignedAccountStateRequest& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetSignedAccountStateRequest& default_instance();
 
  void Swap(GetSignedAccountStateRequest* other);
 
  // implements Message ----------------------------------------------
 
  GetSignedAccountStateRequest* 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);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetSignedAccountStateRequest)
 private:
  inline void set_has_account();
  inline void clear_has_account();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::AccountId* account_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetSignedAccountStateRequest* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetSignedAccountStateResponse : public ::google::protobuf::Message {
 public:
  GetSignedAccountStateResponse();
  virtual ~GetSignedAccountStateResponse();
 
  GetSignedAccountStateResponse(const GetSignedAccountStateResponse& from);
 
  inline GetSignedAccountStateResponse& operator=(const GetSignedAccountStateResponse& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetSignedAccountStateResponse& default_instance();
 
  void Swap(GetSignedAccountStateResponse* other);
 
  // implements Message ----------------------------------------------
 
  GetSignedAccountStateResponse* 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 token = 1;
  inline bool has_token() const;
  inline void clear_token();
  static const int kTokenFieldNumber = 1;
  inline const ::std::string& token() const;
  inline void set_token(const ::std::string& value);
  inline void set_token(const char* value);
  inline void set_token(const char* value, size_t size);
  inline ::std::string* mutable_token();
  inline ::std::string* release_token();
  inline void set_allocated_token(::std::string* token);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetSignedAccountStateResponse)
 private:
  inline void set_has_token();
  inline void clear_has_token();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* token_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetSignedAccountStateResponse* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetGameAccountStateRequest : public ::google::protobuf::Message {
 public:
  GetGameAccountStateRequest();
  virtual ~GetGameAccountStateRequest();
 
  GetGameAccountStateRequest(const GetGameAccountStateRequest& from);
 
  inline GetGameAccountStateRequest& operator=(const GetGameAccountStateRequest& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetGameAccountStateRequest& default_instance();
 
  void Swap(GetGameAccountStateRequest* other);
 
  // implements Message ----------------------------------------------
 
  GetGameAccountStateRequest* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.EntityId account_id = 1 [deprecated = true];
  inline bool has_account_id() const PROTOBUF_DEPRECATED;
  inline void clear_account_id() PROTOBUF_DEPRECATED;
  static const int kAccountIdFieldNumber = 1;
  inline const ::bgs::protocol::EntityId& account_id() const PROTOBUF_DEPRECATED;
  inline ::bgs::protocol::EntityId* mutable_account_id() PROTOBUF_DEPRECATED;
  inline ::bgs::protocol::EntityId* release_account_id() PROTOBUF_DEPRECATED;
  inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id) PROTOBUF_DEPRECATED;
 
  // optional .bgs.protocol.EntityId game_account_id = 2;
  inline bool has_game_account_id() const;
  inline void clear_game_account_id();
  static const int kGameAccountIdFieldNumber = 2;
  inline const ::bgs::protocol::EntityId& game_account_id() const;
  inline ::bgs::protocol::EntityId* mutable_game_account_id();
  inline ::bgs::protocol::EntityId* release_game_account_id();
  inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id);
 
  // optional .bgs.protocol.account.v1.GameAccountFieldOptions options = 10;
  inline bool has_options() const;
  inline void clear_options();
  static const int kOptionsFieldNumber = 10;
  inline const ::bgs::protocol::account::v1::GameAccountFieldOptions& options() const;
  inline ::bgs::protocol::account::v1::GameAccountFieldOptions* mutable_options();
  inline ::bgs::protocol::account::v1::GameAccountFieldOptions* release_options();
  inline void set_allocated_options(::bgs::protocol::account::v1::GameAccountFieldOptions* options);
 
  // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 11;
  inline bool has_tags() const;
  inline void clear_tags();
  static const int kTagsFieldNumber = 11;
  inline const ::bgs::protocol::account::v1::GameAccountFieldTags& tags() const;
  inline ::bgs::protocol::account::v1::GameAccountFieldTags* mutable_tags();
  inline ::bgs::protocol::account::v1::GameAccountFieldTags* release_tags();
  inline void set_allocated_tags(::bgs::protocol::account::v1::GameAccountFieldTags* tags);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameAccountStateRequest)
 private:
  inline void set_has_account_id();
  inline void clear_has_account_id();
  inline void set_has_game_account_id();
  inline void clear_has_game_account_id();
  inline void set_has_options();
  inline void clear_has_options();
  inline void set_has_tags();
  inline void clear_has_tags();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::EntityId* account_id_;
  ::bgs::protocol::EntityId* game_account_id_;
  ::bgs::protocol::account::v1::GameAccountFieldOptions* options_;
  ::bgs::protocol::account::v1::GameAccountFieldTags* tags_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetGameAccountStateRequest* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetGameAccountStateResponse : public ::google::protobuf::Message {
 public:
  GetGameAccountStateResponse();
  virtual ~GetGameAccountStateResponse();
 
  GetGameAccountStateResponse(const GetGameAccountStateResponse& from);
 
  inline GetGameAccountStateResponse& operator=(const GetGameAccountStateResponse& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetGameAccountStateResponse& default_instance();
 
  void Swap(GetGameAccountStateResponse* other);
 
  // implements Message ----------------------------------------------
 
  GetGameAccountStateResponse* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.account.v1.GameAccountState state = 1;
  inline bool has_state() const;
  inline void clear_state();
  static const int kStateFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::GameAccountState& state() const;
  inline ::bgs::protocol::account::v1::GameAccountState* mutable_state();
  inline ::bgs::protocol::account::v1::GameAccountState* release_state();
  inline void set_allocated_state(::bgs::protocol::account::v1::GameAccountState* state);
 
  // optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 2;
  inline bool has_tags() const;
  inline void clear_tags();
  static const int kTagsFieldNumber = 2;
  inline const ::bgs::protocol::account::v1::GameAccountFieldTags& tags() const;
  inline ::bgs::protocol::account::v1::GameAccountFieldTags* mutable_tags();
  inline ::bgs::protocol::account::v1::GameAccountFieldTags* release_tags();
  inline void set_allocated_tags(::bgs::protocol::account::v1::GameAccountFieldTags* tags);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameAccountStateResponse)
 private:
  inline void set_has_state();
  inline void clear_has_state();
  inline void set_has_tags();
  inline void clear_has_tags();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::GameAccountState* state_;
  ::bgs::protocol::account::v1::GameAccountFieldTags* tags_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetGameAccountStateResponse* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetLicensesRequest : public ::google::protobuf::Message {
 public:
  GetLicensesRequest();
  virtual ~GetLicensesRequest();
 
  GetLicensesRequest(const GetLicensesRequest& from);
 
  inline GetLicensesRequest& operator=(const GetLicensesRequest& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetLicensesRequest& default_instance();
 
  void Swap(GetLicensesRequest* other);
 
  // implements Message ----------------------------------------------
 
  GetLicensesRequest* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.EntityId target_id = 1;
  inline bool has_target_id() const;
  inline void clear_target_id();
  static const int kTargetIdFieldNumber = 1;
  inline const ::bgs::protocol::EntityId& target_id() const;
  inline ::bgs::protocol::EntityId* mutable_target_id();
  inline ::bgs::protocol::EntityId* release_target_id();
  inline void set_allocated_target_id(::bgs::protocol::EntityId* target_id);
 
  // optional bool fetch_account_licenses = 2;
  inline bool has_fetch_account_licenses() const;
  inline void clear_fetch_account_licenses();
  static const int kFetchAccountLicensesFieldNumber = 2;
  inline bool fetch_account_licenses() const;
  inline void set_fetch_account_licenses(bool value);
 
  // optional bool fetch_game_account_licenses = 3;
  inline bool has_fetch_game_account_licenses() const;
  inline void clear_fetch_game_account_licenses();
  static const int kFetchGameAccountLicensesFieldNumber = 3;
  inline bool fetch_game_account_licenses() const;
  inline void set_fetch_game_account_licenses(bool value);
 
  // optional bool fetch_dynamic_account_licenses = 4;
  inline bool has_fetch_dynamic_account_licenses() const;
  inline void clear_fetch_dynamic_account_licenses();
  static const int kFetchDynamicAccountLicensesFieldNumber = 4;
  inline bool fetch_dynamic_account_licenses() const;
  inline void set_fetch_dynamic_account_licenses(bool value);
 
  // optional fixed32 program = 5;
  inline bool has_program() const;
  inline void clear_program();
  static const int kProgramFieldNumber = 5;
  inline ::google::protobuf::uint32 program() const;
  inline void set_program(::google::protobuf::uint32 value);
 
  // optional bool exclude_unknown_program = 6 [default = false];
  inline bool has_exclude_unknown_program() const;
  inline void clear_exclude_unknown_program();
  static const int kExcludeUnknownProgramFieldNumber = 6;
  inline bool exclude_unknown_program() const;
  inline void set_exclude_unknown_program(bool value);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetLicensesRequest)
 private:
  inline void set_has_target_id();
  inline void clear_has_target_id();
  inline void set_has_fetch_account_licenses();
  inline void clear_has_fetch_account_licenses();
  inline void set_has_fetch_game_account_licenses();
  inline void clear_has_fetch_game_account_licenses();
  inline void set_has_fetch_dynamic_account_licenses();
  inline void clear_has_fetch_dynamic_account_licenses();
  inline void set_has_program();
  inline void clear_has_program();
  inline void set_has_exclude_unknown_program();
  inline void clear_has_exclude_unknown_program();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::EntityId* target_id_;
  bool fetch_account_licenses_;
  bool fetch_game_account_licenses_;
  bool fetch_dynamic_account_licenses_;
  bool exclude_unknown_program_;
  ::google::protobuf::uint32 program_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetLicensesRequest* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetLicensesResponse : public ::google::protobuf::Message {
 public:
  GetLicensesResponse();
  virtual ~GetLicensesResponse();
 
  GetLicensesResponse(const GetLicensesResponse& from);
 
  inline GetLicensesResponse& operator=(const GetLicensesResponse& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetLicensesResponse& default_instance();
 
  void Swap(GetLicensesResponse* other);
 
  // implements Message ----------------------------------------------
 
  GetLicensesResponse* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // repeated .bgs.protocol.account.v1.AccountLicense licenses = 1;
  inline int licenses_size() const;
  inline void clear_licenses();
  static const int kLicensesFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::AccountLicense& licenses(int index) const;
  inline ::bgs::protocol::account::v1::AccountLicense* mutable_licenses(int index);
  inline ::bgs::protocol::account::v1::AccountLicense* add_licenses();
  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >&
      licenses() const;
  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >*
      mutable_licenses();
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetLicensesResponse)
 private:
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense > licenses_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetLicensesResponse* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetGameSessionInfoRequest : public ::google::protobuf::Message {
 public:
  GetGameSessionInfoRequest();
  virtual ~GetGameSessionInfoRequest();
 
  GetGameSessionInfoRequest(const GetGameSessionInfoRequest& from);
 
  inline GetGameSessionInfoRequest& operator=(const GetGameSessionInfoRequest& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetGameSessionInfoRequest& default_instance();
 
  void Swap(GetGameSessionInfoRequest* other);
 
  // implements Message ----------------------------------------------
 
  GetGameSessionInfoRequest* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.EntityId entity_id = 1;
  inline bool has_entity_id() const;
  inline void clear_entity_id();
  static const int kEntityIdFieldNumber = 1;
  inline const ::bgs::protocol::EntityId& entity_id() const;
  inline ::bgs::protocol::EntityId* mutable_entity_id();
  inline ::bgs::protocol::EntityId* release_entity_id();
  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameSessionInfoRequest)
 private:
  inline void set_has_entity_id();
  inline void clear_has_entity_id();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::EntityId* entity_id_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetGameSessionInfoRequest* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetGameSessionInfoResponse : public ::google::protobuf::Message {
 public:
  GetGameSessionInfoResponse();
  virtual ~GetGameSessionInfoResponse();
 
  GetGameSessionInfoResponse(const GetGameSessionInfoResponse& from);
 
  inline GetGameSessionInfoResponse& operator=(const GetGameSessionInfoResponse& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetGameSessionInfoResponse& default_instance();
 
  void Swap(GetGameSessionInfoResponse* other);
 
  // implements Message ----------------------------------------------
 
  GetGameSessionInfoResponse* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.account.v1.GameSessionInfo session_info = 2;
  inline bool has_session_info() const;
  inline void clear_session_info();
  static const int kSessionInfoFieldNumber = 2;
  inline const ::bgs::protocol::account::v1::GameSessionInfo& session_info() const;
  inline ::bgs::protocol::account::v1::GameSessionInfo* mutable_session_info();
  inline ::bgs::protocol::account::v1::GameSessionInfo* release_session_info();
  inline void set_allocated_session_info(::bgs::protocol::account::v1::GameSessionInfo* session_info);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameSessionInfoResponse)
 private:
  inline void set_has_session_info();
  inline void clear_has_session_info();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::GameSessionInfo* session_info_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetGameSessionInfoResponse* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetGameTimeRemainingInfoRequest : public ::google::protobuf::Message {
 public:
  GetGameTimeRemainingInfoRequest();
  virtual ~GetGameTimeRemainingInfoRequest();
 
  GetGameTimeRemainingInfoRequest(const GetGameTimeRemainingInfoRequest& from);
 
  inline GetGameTimeRemainingInfoRequest& operator=(const GetGameTimeRemainingInfoRequest& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetGameTimeRemainingInfoRequest& default_instance();
 
  void Swap(GetGameTimeRemainingInfoRequest* other);
 
  // implements Message ----------------------------------------------
 
  GetGameTimeRemainingInfoRequest* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.EntityId game_account_id = 1;
  inline bool has_game_account_id() const;
  inline void clear_game_account_id();
  static const int kGameAccountIdFieldNumber = 1;
  inline const ::bgs::protocol::EntityId& game_account_id() const;
  inline ::bgs::protocol::EntityId* mutable_game_account_id();
  inline ::bgs::protocol::EntityId* release_game_account_id();
  inline void set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id);
 
  // optional .bgs.protocol.EntityId account_id = 2;
  inline bool has_account_id() const;
  inline void clear_account_id();
  static const int kAccountIdFieldNumber = 2;
  inline const ::bgs::protocol::EntityId& account_id() const;
  inline ::bgs::protocol::EntityId* mutable_account_id();
  inline ::bgs::protocol::EntityId* release_account_id();
  inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id);
 
  // optional string benefactor_id = 3;
  inline bool has_benefactor_id() const;
  inline void clear_benefactor_id();
  static const int kBenefactorIdFieldNumber = 3;
  inline const ::std::string& benefactor_id() const;
  inline void set_benefactor_id(const ::std::string& value);
  inline void set_benefactor_id(const char* value);
  inline void set_benefactor_id(const char* value, size_t size);
  inline ::std::string* mutable_benefactor_id();
  inline ::std::string* release_benefactor_id();
  inline void set_allocated_benefactor_id(::std::string* benefactor_id);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest)
 private:
  inline void set_has_game_account_id();
  inline void clear_has_game_account_id();
  inline void set_has_account_id();
  inline void clear_has_account_id();
  inline void set_has_benefactor_id();
  inline void clear_has_benefactor_id();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::EntityId* game_account_id_;
  ::bgs::protocol::EntityId* account_id_;
  ::std::string* benefactor_id_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetGameTimeRemainingInfoRequest* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetGameTimeRemainingInfoResponse : public ::google::protobuf::Message {
 public:
  GetGameTimeRemainingInfoResponse();
  virtual ~GetGameTimeRemainingInfoResponse();
 
  GetGameTimeRemainingInfoResponse(const GetGameTimeRemainingInfoResponse& from);
 
  inline GetGameTimeRemainingInfoResponse& operator=(const GetGameTimeRemainingInfoResponse& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetGameTimeRemainingInfoResponse& default_instance();
 
  void Swap(GetGameTimeRemainingInfoResponse* other);
 
  // implements Message ----------------------------------------------
 
  GetGameTimeRemainingInfoResponse* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.account.v1.GameTimeRemainingInfo game_time_remaining_info = 1;
  inline bool has_game_time_remaining_info() const;
  inline void clear_game_time_remaining_info();
  static const int kGameTimeRemainingInfoFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::GameTimeRemainingInfo& game_time_remaining_info() const;
  inline ::bgs::protocol::account::v1::GameTimeRemainingInfo* mutable_game_time_remaining_info();
  inline ::bgs::protocol::account::v1::GameTimeRemainingInfo* release_game_time_remaining_info();
  inline void set_allocated_game_time_remaining_info(::bgs::protocol::account::v1::GameTimeRemainingInfo* game_time_remaining_info);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse)
 private:
  inline void set_has_game_time_remaining_info();
  inline void clear_has_game_time_remaining_info();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::GameTimeRemainingInfo* game_time_remaining_info_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetGameTimeRemainingInfoResponse* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetCAISInfoRequest : public ::google::protobuf::Message {
 public:
  GetCAISInfoRequest();
  virtual ~GetCAISInfoRequest();
 
  GetCAISInfoRequest(const GetCAISInfoRequest& from);
 
  inline GetCAISInfoRequest& operator=(const GetCAISInfoRequest& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetCAISInfoRequest& default_instance();
 
  void Swap(GetCAISInfoRequest* other);
 
  // implements Message ----------------------------------------------
 
  GetCAISInfoRequest* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.EntityId entity_id = 1;
  inline bool has_entity_id() const;
  inline void clear_entity_id();
  static const int kEntityIdFieldNumber = 1;
  inline const ::bgs::protocol::EntityId& entity_id() const;
  inline ::bgs::protocol::EntityId* mutable_entity_id();
  inline ::bgs::protocol::EntityId* release_entity_id();
  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetCAISInfoRequest)
 private:
  inline void set_has_entity_id();
  inline void clear_has_entity_id();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::EntityId* entity_id_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetCAISInfoRequest* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetCAISInfoResponse : public ::google::protobuf::Message {
 public:
  GetCAISInfoResponse();
  virtual ~GetCAISInfoResponse();
 
  GetCAISInfoResponse(const GetCAISInfoResponse& from);
 
  inline GetCAISInfoResponse& operator=(const GetCAISInfoResponse& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetCAISInfoResponse& default_instance();
 
  void Swap(GetCAISInfoResponse* other);
 
  // implements Message ----------------------------------------------
 
  GetCAISInfoResponse* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.account.v1.CAIS cais_info = 1;
  inline bool has_cais_info() const;
  inline void clear_cais_info();
  static const int kCaisInfoFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::CAIS& cais_info() const;
  inline ::bgs::protocol::account::v1::CAIS* mutable_cais_info();
  inline ::bgs::protocol::account::v1::CAIS* release_cais_info();
  inline void set_allocated_cais_info(::bgs::protocol::account::v1::CAIS* cais_info);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetCAISInfoResponse)
 private:
  inline void set_has_cais_info();
  inline void clear_has_cais_info();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::CAIS* cais_info_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetCAISInfoResponse* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetAuthorizedDataRequest : public ::google::protobuf::Message {
 public:
  GetAuthorizedDataRequest();
  virtual ~GetAuthorizedDataRequest();
 
  GetAuthorizedDataRequest(const GetAuthorizedDataRequest& from);
 
  inline GetAuthorizedDataRequest& operator=(const GetAuthorizedDataRequest& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetAuthorizedDataRequest& default_instance();
 
  void Swap(GetAuthorizedDataRequest* other);
 
  // implements Message ----------------------------------------------
 
  GetAuthorizedDataRequest* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.EntityId entity_id = 1;
  inline bool has_entity_id() const;
  inline void clear_entity_id();
  static const int kEntityIdFieldNumber = 1;
  inline const ::bgs::protocol::EntityId& entity_id() const;
  inline ::bgs::protocol::EntityId* mutable_entity_id();
  inline ::bgs::protocol::EntityId* release_entity_id();
  inline void set_allocated_entity_id(::bgs::protocol::EntityId* entity_id);
 
  // repeated string tag = 2;
  inline int tag_size() const;
  inline void clear_tag();
  static const int kTagFieldNumber = 2;
  inline const ::std::string& tag(int index) const;
  inline ::std::string* mutable_tag(int index);
  inline void set_tag(int index, const ::std::string& value);
  inline void set_tag(int index, const char* value);
  inline void set_tag(int index, const char* value, size_t size);
  inline ::std::string* add_tag();
  inline void add_tag(const ::std::string& value);
  inline void add_tag(const char* value);
  inline void add_tag(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& tag() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_tag();
 
  // optional bool privileged_network = 3;
  inline bool has_privileged_network() const;
  inline void clear_privileged_network();
  static const int kPrivilegedNetworkFieldNumber = 3;
  inline bool privileged_network() const;
  inline void set_privileged_network(bool value);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAuthorizedDataRequest)
 private:
  inline void set_has_entity_id();
  inline void clear_has_entity_id();
  inline void set_has_privileged_network();
  inline void clear_has_privileged_network();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::EntityId* entity_id_;
  ::google::protobuf::RepeatedPtrField< ::std::string> tag_;
  bool privileged_network_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetAuthorizedDataRequest* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetAuthorizedDataResponse : public ::google::protobuf::Message {
 public:
  GetAuthorizedDataResponse();
  virtual ~GetAuthorizedDataResponse();
 
  GetAuthorizedDataResponse(const GetAuthorizedDataResponse& from);
 
  inline GetAuthorizedDataResponse& operator=(const GetAuthorizedDataResponse& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetAuthorizedDataResponse& default_instance();
 
  void Swap(GetAuthorizedDataResponse* other);
 
  // implements Message ----------------------------------------------
 
  GetAuthorizedDataResponse* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // repeated .bgs.protocol.account.v1.AuthorizedData data = 1;
  inline int data_size() const;
  inline void clear_data();
  static const int kDataFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::AuthorizedData& data(int index) const;
  inline ::bgs::protocol::account::v1::AuthorizedData* mutable_data(int index);
  inline ::bgs::protocol::account::v1::AuthorizedData* add_data();
  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AuthorizedData >&
      data() const;
  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AuthorizedData >*
      mutable_data();
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAuthorizedDataResponse)
 private:
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AuthorizedData > data_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetAuthorizedDataResponse* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetAccountInfoRequest : public ::google::protobuf::Message {
 public:
  GetAccountInfoRequest();
  virtual ~GetAccountInfoRequest();
 
  GetAccountInfoRequest(const GetAccountInfoRequest& from);
 
  inline GetAccountInfoRequest& operator=(const GetAccountInfoRequest& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetAccountInfoRequest& default_instance();
 
  void Swap(GetAccountInfoRequest* other);
 
  // implements Message ----------------------------------------------
 
  GetAccountInfoRequest* 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.EntityId account_id = 1;
  inline bool has_account_id() const;
  inline void clear_account_id();
  static const int kAccountIdFieldNumber = 1;
  inline const ::bgs::protocol::EntityId& account_id() const;
  inline ::bgs::protocol::EntityId* mutable_account_id();
  inline ::bgs::protocol::EntityId* release_account_id();
  inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountInfoRequest)
 private:
  inline void set_has_account_id();
  inline void clear_has_account_id();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::EntityId* account_id_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetAccountInfoRequest* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetAccountInfoResponse : public ::google::protobuf::Message {
 public:
  GetAccountInfoResponse();
  virtual ~GetAccountInfoResponse();
 
  GetAccountInfoResponse(const GetAccountInfoResponse& from);
 
  inline GetAccountInfoResponse& operator=(const GetAccountInfoResponse& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetAccountInfoResponse& default_instance();
 
  void Swap(GetAccountInfoResponse* other);
 
  // implements Message ----------------------------------------------
 
  GetAccountInfoResponse* 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.AccountInfo account_info = 1;
  inline bool has_account_info() const;
  inline void clear_account_info();
  static const int kAccountInfoFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::AccountInfo& account_info() const;
  inline ::bgs::protocol::account::v1::AccountInfo* mutable_account_info();
  inline ::bgs::protocol::account::v1::AccountInfo* release_account_info();
  inline void set_allocated_account_info(::bgs::protocol::account::v1::AccountInfo* account_info);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountInfoResponse)
 private:
  inline void set_has_account_info();
  inline void clear_has_account_info();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::AccountInfo* account_info_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetAccountInfoResponse* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetAccountPlatformRestrictionsRequest : public ::google::protobuf::Message {
 public:
  GetAccountPlatformRestrictionsRequest();
  virtual ~GetAccountPlatformRestrictionsRequest();
 
  GetAccountPlatformRestrictionsRequest(const GetAccountPlatformRestrictionsRequest& from);
 
  inline GetAccountPlatformRestrictionsRequest& operator=(const GetAccountPlatformRestrictionsRequest& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetAccountPlatformRestrictionsRequest& default_instance();
 
  void Swap(GetAccountPlatformRestrictionsRequest* other);
 
  // implements Message ----------------------------------------------
 
  GetAccountPlatformRestrictionsRequest* 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.EntityId account_id = 1;
  inline bool has_account_id() const;
  inline void clear_account_id();
  static const int kAccountIdFieldNumber = 1;
  inline const ::bgs::protocol::EntityId& account_id() const;
  inline ::bgs::protocol::EntityId* mutable_account_id();
  inline ::bgs::protocol::EntityId* release_account_id();
  inline void set_allocated_account_id(::bgs::protocol::EntityId* account_id);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountPlatformRestrictionsRequest)
 private:
  inline void set_has_account_id();
  inline void clear_has_account_id();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::EntityId* account_id_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetAccountPlatformRestrictionsRequest* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GetAccountPlatformRestrictionsResponse : public ::google::protobuf::Message {
 public:
  GetAccountPlatformRestrictionsResponse();
  virtual ~GetAccountPlatformRestrictionsResponse();
 
  GetAccountPlatformRestrictionsResponse(const GetAccountPlatformRestrictionsResponse& from);
 
  inline GetAccountPlatformRestrictionsResponse& operator=(const GetAccountPlatformRestrictionsResponse& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GetAccountPlatformRestrictionsResponse& default_instance();
 
  void Swap(GetAccountPlatformRestrictionsResponse* other);
 
  // implements Message ----------------------------------------------
 
  GetAccountPlatformRestrictionsResponse* 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.AccountPlatformRestrictionInfo restriction_info = 1;
  inline bool has_restriction_info() const;
  inline void clear_restriction_info();
  static const int kRestrictionInfoFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::AccountPlatformRestrictionInfo& restriction_info() const;
  inline ::bgs::protocol::account::v1::AccountPlatformRestrictionInfo* mutable_restriction_info();
  inline ::bgs::protocol::account::v1::AccountPlatformRestrictionInfo* release_restriction_info();
  inline void set_allocated_restriction_info(::bgs::protocol::account::v1::AccountPlatformRestrictionInfo* restriction_info);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GetAccountPlatformRestrictionsResponse)
 private:
  inline void set_has_restriction_info();
  inline void clear_has_restriction_info();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::AccountPlatformRestrictionInfo* restriction_info_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GetAccountPlatformRestrictionsResponse* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API AccountStateNotification : public ::google::protobuf::Message {
 public:
  AccountStateNotification();
  virtual ~AccountStateNotification();
 
  AccountStateNotification(const AccountStateNotification& from);
 
  inline AccountStateNotification& operator=(const AccountStateNotification& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const AccountStateNotification& default_instance();
 
  void Swap(AccountStateNotification* other);
 
  // implements Message ----------------------------------------------
 
  AccountStateNotification* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.account.v1.AccountState account_state = 1;
  inline bool has_account_state() const;
  inline void clear_account_state();
  static const int kAccountStateFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::AccountState& account_state() const;
  inline ::bgs::protocol::account::v1::AccountState* mutable_account_state();
  inline ::bgs::protocol::account::v1::AccountState* release_account_state();
  inline void set_allocated_account_state(::bgs::protocol::account::v1::AccountState* account_state);
 
  // optional uint64 subscriber_id = 2 [deprecated = true];
  inline bool has_subscriber_id() const PROTOBUF_DEPRECATED;
  inline void clear_subscriber_id() PROTOBUF_DEPRECATED;
  static const int kSubscriberIdFieldNumber = 2;
  inline ::google::protobuf::uint64 subscriber_id() const PROTOBUF_DEPRECATED;
  inline void set_subscriber_id(::google::protobuf::uint64 value) PROTOBUF_DEPRECATED;
 
  // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
  inline bool has_account_tags() const;
  inline void clear_account_tags();
  static const int kAccountTagsFieldNumber = 3;
  inline const ::bgs::protocol::account::v1::AccountFieldTags& account_tags() const;
  inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_account_tags();
  inline ::bgs::protocol::account::v1::AccountFieldTags* release_account_tags();
  inline void set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags);
 
  // optional bool subscription_completed = 4;
  inline bool has_subscription_completed() const;
  inline void clear_subscription_completed();
  static const int kSubscriptionCompletedFieldNumber = 4;
  inline bool subscription_completed() const;
  inline void set_subscription_completed(bool value);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.AccountStateNotification)
 private:
  inline void set_has_account_state();
  inline void clear_has_account_state();
  inline void set_has_subscriber_id();
  inline void clear_has_subscriber_id();
  inline void set_has_account_tags();
  inline void clear_has_account_tags();
  inline void set_has_subscription_completed();
  inline void clear_has_subscription_completed();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::AccountState* account_state_;
  ::google::protobuf::uint64 subscriber_id_;
  ::bgs::protocol::account::v1::AccountFieldTags* account_tags_;
  bool subscription_completed_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static AccountStateNotification* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GameAccountStateNotification : public ::google::protobuf::Message {
 public:
  GameAccountStateNotification();
  virtual ~GameAccountStateNotification();
 
  GameAccountStateNotification(const GameAccountStateNotification& from);
 
  inline GameAccountStateNotification& operator=(const GameAccountStateNotification& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GameAccountStateNotification& default_instance();
 
  void Swap(GameAccountStateNotification* other);
 
  // implements Message ----------------------------------------------
 
  GameAccountStateNotification* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1;
  inline bool has_game_account_state() const;
  inline void clear_game_account_state();
  static const int kGameAccountStateFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::GameAccountState& game_account_state() const;
  inline ::bgs::protocol::account::v1::GameAccountState* mutable_game_account_state();
  inline ::bgs::protocol::account::v1::GameAccountState* release_game_account_state();
  inline void set_allocated_game_account_state(::bgs::protocol::account::v1::GameAccountState* game_account_state);
 
  // optional uint64 subscriber_id = 2 [deprecated = true];
  inline bool has_subscriber_id() const PROTOBUF_DEPRECATED;
  inline void clear_subscriber_id() PROTOBUF_DEPRECATED;
  static const int kSubscriberIdFieldNumber = 2;
  inline ::google::protobuf::uint64 subscriber_id() const PROTOBUF_DEPRECATED;
  inline void set_subscriber_id(::google::protobuf::uint64 value) PROTOBUF_DEPRECATED;
 
  // optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 3;
  inline bool has_game_account_tags() const;
  inline void clear_game_account_tags();
  static const int kGameAccountTagsFieldNumber = 3;
  inline const ::bgs::protocol::account::v1::GameAccountFieldTags& game_account_tags() const;
  inline ::bgs::protocol::account::v1::GameAccountFieldTags* mutable_game_account_tags();
  inline ::bgs::protocol::account::v1::GameAccountFieldTags* release_game_account_tags();
  inline void set_allocated_game_account_tags(::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags);
 
  // optional bool subscription_completed = 4;
  inline bool has_subscription_completed() const;
  inline void clear_subscription_completed();
  static const int kSubscriptionCompletedFieldNumber = 4;
  inline bool subscription_completed() const;
  inline void set_subscription_completed(bool value);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountStateNotification)
 private:
  inline void set_has_game_account_state();
  inline void clear_has_game_account_state();
  inline void set_has_subscriber_id();
  inline void clear_has_subscriber_id();
  inline void set_has_game_account_tags();
  inline void clear_has_game_account_tags();
  inline void set_has_subscription_completed();
  inline void clear_has_subscription_completed();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::GameAccountState* game_account_state_;
  ::google::protobuf::uint64 subscriber_id_;
  ::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags_;
  bool subscription_completed_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GameAccountStateNotification* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GameAccountNotification : public ::google::protobuf::Message {
 public:
  GameAccountNotification();
  virtual ~GameAccountNotification();
 
  GameAccountNotification(const GameAccountNotification& from);
 
  inline GameAccountNotification& operator=(const GameAccountNotification& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GameAccountNotification& default_instance();
 
  void Swap(GameAccountNotification* other);
 
  // implements Message ----------------------------------------------
 
  GameAccountNotification* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 1;
  inline int game_accounts_size() const;
  inline void clear_game_accounts();
  static const int kGameAccountsFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::GameAccountList& game_accounts(int index) const;
  inline ::bgs::protocol::account::v1::GameAccountList* mutable_game_accounts(int index);
  inline ::bgs::protocol::account::v1::GameAccountList* add_game_accounts();
  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >&
      game_accounts() const;
  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >*
      mutable_game_accounts();
 
  // optional uint64 subscriber_id = 2;
  inline bool has_subscriber_id() const;
  inline void clear_subscriber_id();
  static const int kSubscriberIdFieldNumber = 2;
  inline ::google::protobuf::uint64 subscriber_id() const;
  inline void set_subscriber_id(::google::protobuf::uint64 value);
 
  // optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
  inline bool has_account_tags() const;
  inline void clear_account_tags();
  static const int kAccountTagsFieldNumber = 3;
  inline const ::bgs::protocol::account::v1::AccountFieldTags& account_tags() const;
  inline ::bgs::protocol::account::v1::AccountFieldTags* mutable_account_tags();
  inline ::bgs::protocol::account::v1::AccountFieldTags* release_account_tags();
  inline void set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountNotification)
 private:
  inline void set_has_subscriber_id();
  inline void clear_has_subscriber_id();
  inline void set_has_account_tags();
  inline void clear_has_account_tags();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList > game_accounts_;
  ::google::protobuf::uint64 subscriber_id_;
  ::bgs::protocol::account::v1::AccountFieldTags* account_tags_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GameAccountNotification* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API GameAccountSessionNotification : public ::google::protobuf::Message {
 public:
  GameAccountSessionNotification();
  virtual ~GameAccountSessionNotification();
 
  GameAccountSessionNotification(const GameAccountSessionNotification& from);
 
  inline GameAccountSessionNotification& operator=(const GameAccountSessionNotification& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const GameAccountSessionNotification& default_instance();
 
  void Swap(GameAccountSessionNotification* other);
 
  // implements Message ----------------------------------------------
 
  GameAccountSessionNotification* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
  inline bool has_game_account() const;
  inline void clear_game_account();
  static const int kGameAccountFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const;
  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account();
  inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account();
  inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account);
 
  // optional .bgs.protocol.account.v1.GameSessionUpdateInfo session_info = 2;
  inline bool has_session_info() const;
  inline void clear_session_info();
  static const int kSessionInfoFieldNumber = 2;
  inline const ::bgs::protocol::account::v1::GameSessionUpdateInfo& session_info() const;
  inline ::bgs::protocol::account::v1::GameSessionUpdateInfo* mutable_session_info();
  inline ::bgs::protocol::account::v1::GameSessionUpdateInfo* release_session_info();
  inline void set_allocated_session_info(::bgs::protocol::account::v1::GameSessionUpdateInfo* session_info);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.account.v1.GameAccountSessionNotification)
 private:
  inline void set_has_game_account();
  inline void clear_has_game_account();
  inline void set_has_session_info();
  inline void clear_has_session_info();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
  ::bgs::protocol::account::v1::GameSessionUpdateInfo* session_info_;
  friend void TC_PROTO_API protobuf_AddDesc_account_5fservice_2eproto();
  friend void protobuf_AssignDesc_account_5fservice_2eproto();
  friend void protobuf_ShutdownFile_account_5fservice_2eproto();
 
  void InitAsDefaultInstance();
  static GameAccountSessionNotification* default_instance_;
};
// ===================================================================
 
class TC_PROTO_API AccountService : public ServiceBase
{
 public:
 
  explicit AccountService(bool use_original_hash);
  AccountService(AccountService const&) = delete;
  AccountService(AccountService&&) = delete;
  AccountService& operator=(AccountService const&) = delete;
  AccountService& operator=(AccountService&&) = delete;
  virtual ~AccountService();
 
  typedef std::integral_constant<uint32, 0x62DA0891u> OriginalHash;
  typedef std::integral_constant<uint32, 0x1E4DC42Fu> NameHash;
 
  static google::protobuf::ServiceDescriptor const* descriptor();
 
  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) final;
 
 protected:
  // server methods --------------------------------------------------
  virtual uint32 HandleResolveAccount(::bgs::protocol::account::v1::ResolveAccountRequest const* request, ::bgs::protocol::account::v1::ResolveAccountResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
  virtual uint32 HandleSubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, ::bgs::protocol::account::v1::SubscriptionUpdateResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
  virtual uint32 HandleUnsubscribe(::bgs::protocol::account::v1::SubscriptionUpdateRequest const* request, ::bgs::protocol::NoData* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
  virtual uint32 HandleGetAccountState(::bgs::protocol::account::v1::GetAccountStateRequest const* request, ::bgs::protocol::account::v1::GetAccountStateResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
  virtual uint32 HandleGetGameAccountState(::bgs::protocol::account::v1::GetGameAccountStateRequest const* request, ::bgs::protocol::account::v1::GetGameAccountStateResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
  virtual uint32 HandleGetLicenses(::bgs::protocol::account::v1::GetLicensesRequest const* request, ::bgs::protocol::account::v1::GetLicensesResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
  virtual uint32 HandleGetGameTimeRemainingInfo(::bgs::protocol::account::v1::GetGameTimeRemainingInfoRequest const* request, ::bgs::protocol::account::v1::GetGameTimeRemainingInfoResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
  virtual uint32 HandleGetGameSessionInfo(::bgs::protocol::account::v1::GetGameSessionInfoRequest const* request, ::bgs::protocol::account::v1::GetGameSessionInfoResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
  virtual uint32 HandleGetCAISInfo(::bgs::protocol::account::v1::GetCAISInfoRequest const* request, ::bgs::protocol::account::v1::GetCAISInfoResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
  virtual uint32 HandleGetAuthorizedData(::bgs::protocol::account::v1::GetAuthorizedDataRequest const* request, ::bgs::protocol::account::v1::GetAuthorizedDataResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
  virtual uint32 HandleGetSignedAccountState(::bgs::protocol::account::v1::GetSignedAccountStateRequest const* request, ::bgs::protocol::account::v1::GetSignedAccountStateResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
  virtual uint32 HandleGetAccountInfo(::bgs::protocol::account::v1::GetAccountInfoRequest const* request, ::bgs::protocol::account::v1::GetAccountInfoResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
  virtual uint32 HandleGetAccountPlatformRestrictions(::bgs::protocol::account::v1::GetAccountPlatformRestrictionsRequest const* request, ::bgs::protocol::account::v1::GetAccountPlatformRestrictionsResponse* response, std::function<void(ServiceBase*, uint32, ::google::protobuf::Message const*)>& continuation);
 
 private:
  void ParseAndHandleResolveAccount(uint32 token, uint32 methodId, MessageBuffer& buffer);
  void ParseAndHandleSubscribe(uint32 token, uint32 methodId, MessageBuffer& buffer);
  void ParseAndHandleUnsubscribe(uint32 token, uint32 methodId, MessageBuffer& buffer);
  void ParseAndHandleGetAccountState(uint32 token, uint32 methodId, MessageBuffer& buffer);
  void ParseAndHandleGetGameAccountState(uint32 token, uint32 methodId, MessageBuffer& buffer);
  void ParseAndHandleGetLicenses(uint32 token, uint32 methodId, MessageBuffer& buffer);
  void ParseAndHandleGetGameTimeRemainingInfo(uint32 token, uint32 methodId, MessageBuffer& buffer);
  void ParseAndHandleGetGameSessionInfo(uint32 token, uint32 methodId, MessageBuffer& buffer);
  void ParseAndHandleGetCAISInfo(uint32 token, uint32 methodId, MessageBuffer& buffer);
  void ParseAndHandleGetAuthorizedData(uint32 token, uint32 methodId, MessageBuffer& buffer);
  void ParseAndHandleGetSignedAccountState(uint32 token, uint32 methodId, MessageBuffer& buffer);
  void ParseAndHandleGetAccountInfo(uint32 token, uint32 methodId, MessageBuffer& buffer);
  void ParseAndHandleGetAccountPlatformRestrictions(uint32 token, uint32 methodId, MessageBuffer& buffer);
};
 
// -------------------------------------------------------------------
 
class TC_PROTO_API AccountListener : public ServiceBase
{
 public:
 
  explicit AccountListener(bool use_original_hash);
  AccountListener(AccountListener const&) = delete;
  AccountListener(AccountListener&&) = delete;
  AccountListener& operator=(AccountListener const&) = delete;
  AccountListener& operator=(AccountListener&&) = delete;
  virtual ~AccountListener();
 
  typedef std::integral_constant<uint32, 0x54DFDA17u> OriginalHash;
  typedef std::integral_constant<uint32, 0x7807483Cu> NameHash;
 
  static google::protobuf::ServiceDescriptor const* descriptor();
 
  // client methods --------------------------------------------------
  void OnAccountStateUpdated(::bgs::protocol::account::v1::AccountStateNotification const* request, bool client = false, bool server = false);
  void OnGameAccountStateUpdated(::bgs::protocol::account::v1::GameAccountStateNotification const* request, bool client = false, bool server = false);
  void OnGameAccountsUpdated(::bgs::protocol::account::v1::GameAccountNotification const* request, bool client = false, bool server = false);
  void OnGameSessionUpdated(::bgs::protocol::account::v1::GameAccountSessionNotification const* request, bool client = false, bool server = false);
 
  void CallServerMethod(uint32 token, uint32 methodId, MessageBuffer buffer) final;
};
 
// ===================================================================
 
// ===================================================================
 
// ResolveAccountRequest
 
// optional .bgs.protocol.account.v1.AccountReference ref = 1;
inline bool ResolveAccountRequest::has_ref() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ResolveAccountRequest::set_has_ref() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ResolveAccountRequest::clear_has_ref() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ResolveAccountRequest::clear_ref() {
  if (ref_ != NULL) ref_->::bgs::protocol::account::v1::AccountReference::Clear();
  clear_has_ref();
}
inline const ::bgs::protocol::account::v1::AccountReference& ResolveAccountRequest::ref() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ResolveAccountRequest.ref)
  return ref_ != NULL ? *ref_ : *default_instance_->ref_;
}
inline ::bgs::protocol::account::v1::AccountReference* ResolveAccountRequest::mutable_ref() {
  set_has_ref();
  if (ref_ == NULL) ref_ = new ::bgs::protocol::account::v1::AccountReference;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.ResolveAccountRequest.ref)
  return ref_;
}
inline ::bgs::protocol::account::v1::AccountReference* ResolveAccountRequest::release_ref() {
  clear_has_ref();
  ::bgs::protocol::account::v1::AccountReference* temp = ref_;
  ref_ = NULL;
  return temp;
}
inline void ResolveAccountRequest::set_allocated_ref(::bgs::protocol::account::v1::AccountReference* ref) {
  delete ref_;
  ref_ = ref;
  if (ref) {
    set_has_ref();
  } else {
    clear_has_ref();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.ResolveAccountRequest.ref)
}
 
// optional bool fetch_id = 12;
inline bool ResolveAccountRequest::has_fetch_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ResolveAccountRequest::set_has_fetch_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ResolveAccountRequest::clear_has_fetch_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ResolveAccountRequest::clear_fetch_id() {
  fetch_id_ = false;
  clear_has_fetch_id();
}
inline bool ResolveAccountRequest::fetch_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ResolveAccountRequest.fetch_id)
  return fetch_id_;
}
inline void ResolveAccountRequest::set_fetch_id(bool value) {
  set_has_fetch_id();
  fetch_id_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.ResolveAccountRequest.fetch_id)
}
 
// -------------------------------------------------------------------
 
// ResolveAccountResponse
 
// optional .bgs.protocol.account.v1.AccountId id = 12;
inline bool ResolveAccountResponse::has_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ResolveAccountResponse::set_has_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ResolveAccountResponse::clear_has_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ResolveAccountResponse::clear_id() {
  if (id_ != NULL) id_->::bgs::protocol::account::v1::AccountId::Clear();
  clear_has_id();
}
inline const ::bgs::protocol::account::v1::AccountId& ResolveAccountResponse::id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.ResolveAccountResponse.id)
  return id_ != NULL ? *id_ : *default_instance_->id_;
}
inline ::bgs::protocol::account::v1::AccountId* ResolveAccountResponse::mutable_id() {
  set_has_id();
  if (id_ == NULL) id_ = new ::bgs::protocol::account::v1::AccountId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.ResolveAccountResponse.id)
  return id_;
}
inline ::bgs::protocol::account::v1::AccountId* ResolveAccountResponse::release_id() {
  clear_has_id();
  ::bgs::protocol::account::v1::AccountId* temp = id_;
  id_ = NULL;
  return temp;
}
inline void ResolveAccountResponse::set_allocated_id(::bgs::protocol::account::v1::AccountId* id) {
  delete id_;
  id_ = id;
  if (id) {
    set_has_id();
  } else {
    clear_has_id();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.ResolveAccountResponse.id)
}
 
// -------------------------------------------------------------------
 
// GameAccountFlagUpdateRequest
 
// optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
inline bool GameAccountFlagUpdateRequest::has_game_account() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GameAccountFlagUpdateRequest::set_has_game_account() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GameAccountFlagUpdateRequest::clear_has_game_account() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GameAccountFlagUpdateRequest::clear_game_account() {
  if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
  clear_has_game_account();
}
inline const ::bgs::protocol::account::v1::GameAccountHandle& GameAccountFlagUpdateRequest::game_account() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.game_account)
  return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountFlagUpdateRequest::mutable_game_account() {
  set_has_game_account();
  if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.game_account)
  return game_account_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountFlagUpdateRequest::release_game_account() {
  clear_has_game_account();
  ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_;
  game_account_ = NULL;
  return temp;
}
inline void GameAccountFlagUpdateRequest::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) {
  delete game_account_;
  game_account_ = game_account;
  if (game_account) {
    set_has_game_account();
  } else {
    clear_has_game_account();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.game_account)
}
 
// optional uint64 flag = 2;
inline bool GameAccountFlagUpdateRequest::has_flag() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GameAccountFlagUpdateRequest::set_has_flag() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GameAccountFlagUpdateRequest::clear_has_flag() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GameAccountFlagUpdateRequest::clear_flag() {
  flag_ = GOOGLE_ULONGLONG(0);
  clear_has_flag();
}
inline ::google::protobuf::uint64 GameAccountFlagUpdateRequest::flag() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.flag)
  return flag_;
}
inline void GameAccountFlagUpdateRequest::set_flag(::google::protobuf::uint64 value) {
  set_has_flag();
  flag_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.flag)
}
 
// optional bool active = 3;
inline bool GameAccountFlagUpdateRequest::has_active() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GameAccountFlagUpdateRequest::set_has_active() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GameAccountFlagUpdateRequest::clear_has_active() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GameAccountFlagUpdateRequest::clear_active() {
  active_ = false;
  clear_has_active();
}
inline bool GameAccountFlagUpdateRequest::active() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.active)
  return active_;
}
inline void GameAccountFlagUpdateRequest::set_active(bool value) {
  set_has_active();
  active_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountFlagUpdateRequest.active)
}
 
// -------------------------------------------------------------------
 
// SubscriptionUpdateRequest
 
// repeated .bgs.protocol.account.v1.SubscriberReference ref = 2;
inline int SubscriptionUpdateRequest::ref_size() const {
  return ref_.size();
}
inline void SubscriptionUpdateRequest::clear_ref() {
  ref_.Clear();
}
inline const ::bgs::protocol::account::v1::SubscriberReference& SubscriptionUpdateRequest::ref(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriptionUpdateRequest.ref)
  return ref_.Get(index);
}
inline ::bgs::protocol::account::v1::SubscriberReference* SubscriptionUpdateRequest::mutable_ref(int index) {
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.SubscriptionUpdateRequest.ref)
  return ref_.Mutable(index);
}
inline ::bgs::protocol::account::v1::SubscriberReference* SubscriptionUpdateRequest::add_ref() {
  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.SubscriptionUpdateRequest.ref)
  return ref_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >&
SubscriptionUpdateRequest::ref() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.SubscriptionUpdateRequest.ref)
  return ref_;
}
inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >*
SubscriptionUpdateRequest::mutable_ref() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.SubscriptionUpdateRequest.ref)
  return &ref_;
}
 
// -------------------------------------------------------------------
 
// SubscriptionUpdateResponse
 
// repeated .bgs.protocol.account.v1.SubscriberReference ref = 1;
inline int SubscriptionUpdateResponse::ref_size() const {
  return ref_.size();
}
inline void SubscriptionUpdateResponse::clear_ref() {
  ref_.Clear();
}
inline const ::bgs::protocol::account::v1::SubscriberReference& SubscriptionUpdateResponse::ref(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.SubscriptionUpdateResponse.ref)
  return ref_.Get(index);
}
inline ::bgs::protocol::account::v1::SubscriberReference* SubscriptionUpdateResponse::mutable_ref(int index) {
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.SubscriptionUpdateResponse.ref)
  return ref_.Mutable(index);
}
inline ::bgs::protocol::account::v1::SubscriberReference* SubscriptionUpdateResponse::add_ref() {
  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.SubscriptionUpdateResponse.ref)
  return ref_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >&
SubscriptionUpdateResponse::ref() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.SubscriptionUpdateResponse.ref)
  return ref_;
}
inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::SubscriberReference >*
SubscriptionUpdateResponse::mutable_ref() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.SubscriptionUpdateResponse.ref)
  return &ref_;
}
 
// -------------------------------------------------------------------
 
// GetAccountStateRequest
 
// optional .bgs.protocol.EntityId entity_id = 1;
inline bool GetAccountStateRequest::has_entity_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetAccountStateRequest::set_has_entity_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetAccountStateRequest::clear_has_entity_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetAccountStateRequest::clear_entity_id() {
  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
  clear_has_entity_id();
}
inline const ::bgs::protocol::EntityId& GetAccountStateRequest::entity_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateRequest.entity_id)
  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
}
inline ::bgs::protocol::EntityId* GetAccountStateRequest::mutable_entity_id() {
  set_has_entity_id();
  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountStateRequest.entity_id)
  return entity_id_;
}
inline ::bgs::protocol::EntityId* GetAccountStateRequest::release_entity_id() {
  clear_has_entity_id();
  ::bgs::protocol::EntityId* temp = entity_id_;
  entity_id_ = NULL;
  return temp;
}
inline void GetAccountStateRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
  delete entity_id_;
  entity_id_ = entity_id;
  if (entity_id) {
    set_has_entity_id();
  } else {
    clear_has_entity_id();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountStateRequest.entity_id)
}
 
// optional uint32 program = 2;
inline bool GetAccountStateRequest::has_program() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetAccountStateRequest::set_has_program() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetAccountStateRequest::clear_has_program() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetAccountStateRequest::clear_program() {
  program_ = 0u;
  clear_has_program();
}
inline ::google::protobuf::uint32 GetAccountStateRequest::program() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateRequest.program)
  return program_;
}
inline void GetAccountStateRequest::set_program(::google::protobuf::uint32 value) {
  set_has_program();
  program_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountStateRequest.program)
}
 
// optional uint32 region = 3;
inline bool GetAccountStateRequest::has_region() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GetAccountStateRequest::set_has_region() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GetAccountStateRequest::clear_has_region() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GetAccountStateRequest::clear_region() {
  region_ = 0u;
  clear_has_region();
}
inline ::google::protobuf::uint32 GetAccountStateRequest::region() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateRequest.region)
  return region_;
}
inline void GetAccountStateRequest::set_region(::google::protobuf::uint32 value) {
  set_has_region();
  region_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAccountStateRequest.region)
}
 
// optional .bgs.protocol.account.v1.AccountFieldOptions options = 10;
inline bool GetAccountStateRequest::has_options() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void GetAccountStateRequest::set_has_options() {
  _has_bits_[0] |= 0x00000008u;
}
inline void GetAccountStateRequest::clear_has_options() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void GetAccountStateRequest::clear_options() {
  if (options_ != NULL) options_->::bgs::protocol::account::v1::AccountFieldOptions::Clear();
  clear_has_options();
}
inline const ::bgs::protocol::account::v1::AccountFieldOptions& GetAccountStateRequest::options() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateRequest.options)
  return options_ != NULL ? *options_ : *default_instance_->options_;
}
inline ::bgs::protocol::account::v1::AccountFieldOptions* GetAccountStateRequest::mutable_options() {
  set_has_options();
  if (options_ == NULL) options_ = new ::bgs::protocol::account::v1::AccountFieldOptions;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountStateRequest.options)
  return options_;
}
inline ::bgs::protocol::account::v1::AccountFieldOptions* GetAccountStateRequest::release_options() {
  clear_has_options();
  ::bgs::protocol::account::v1::AccountFieldOptions* temp = options_;
  options_ = NULL;
  return temp;
}
inline void GetAccountStateRequest::set_allocated_options(::bgs::protocol::account::v1::AccountFieldOptions* options) {
  delete options_;
  options_ = options;
  if (options) {
    set_has_options();
  } else {
    clear_has_options();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountStateRequest.options)
}
 
// optional .bgs.protocol.account.v1.AccountFieldTags tags = 11;
inline bool GetAccountStateRequest::has_tags() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void GetAccountStateRequest::set_has_tags() {
  _has_bits_[0] |= 0x00000010u;
}
inline void GetAccountStateRequest::clear_has_tags() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void GetAccountStateRequest::clear_tags() {
  if (tags_ != NULL) tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear();
  clear_has_tags();
}
inline const ::bgs::protocol::account::v1::AccountFieldTags& GetAccountStateRequest::tags() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateRequest.tags)
  return tags_ != NULL ? *tags_ : *default_instance_->tags_;
}
inline ::bgs::protocol::account::v1::AccountFieldTags* GetAccountStateRequest::mutable_tags() {
  set_has_tags();
  if (tags_ == NULL) tags_ = new ::bgs::protocol::account::v1::AccountFieldTags;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountStateRequest.tags)
  return tags_;
}
inline ::bgs::protocol::account::v1::AccountFieldTags* GetAccountStateRequest::release_tags() {
  clear_has_tags();
  ::bgs::protocol::account::v1::AccountFieldTags* temp = tags_;
  tags_ = NULL;
  return temp;
}
inline void GetAccountStateRequest::set_allocated_tags(::bgs::protocol::account::v1::AccountFieldTags* tags) {
  delete tags_;
  tags_ = tags;
  if (tags) {
    set_has_tags();
  } else {
    clear_has_tags();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountStateRequest.tags)
}
 
// -------------------------------------------------------------------
 
// GetAccountStateResponse
 
// optional .bgs.protocol.account.v1.AccountState state = 1;
inline bool GetAccountStateResponse::has_state() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetAccountStateResponse::set_has_state() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetAccountStateResponse::clear_has_state() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetAccountStateResponse::clear_state() {
  if (state_ != NULL) state_->::bgs::protocol::account::v1::AccountState::Clear();
  clear_has_state();
}
inline const ::bgs::protocol::account::v1::AccountState& GetAccountStateResponse::state() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateResponse.state)
  return state_ != NULL ? *state_ : *default_instance_->state_;
}
inline ::bgs::protocol::account::v1::AccountState* GetAccountStateResponse::mutable_state() {
  set_has_state();
  if (state_ == NULL) state_ = new ::bgs::protocol::account::v1::AccountState;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountStateResponse.state)
  return state_;
}
inline ::bgs::protocol::account::v1::AccountState* GetAccountStateResponse::release_state() {
  clear_has_state();
  ::bgs::protocol::account::v1::AccountState* temp = state_;
  state_ = NULL;
  return temp;
}
inline void GetAccountStateResponse::set_allocated_state(::bgs::protocol::account::v1::AccountState* state) {
  delete state_;
  state_ = state;
  if (state) {
    set_has_state();
  } else {
    clear_has_state();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountStateResponse.state)
}
 
// optional .bgs.protocol.account.v1.AccountFieldTags tags = 2;
inline bool GetAccountStateResponse::has_tags() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetAccountStateResponse::set_has_tags() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetAccountStateResponse::clear_has_tags() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetAccountStateResponse::clear_tags() {
  if (tags_ != NULL) tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear();
  clear_has_tags();
}
inline const ::bgs::protocol::account::v1::AccountFieldTags& GetAccountStateResponse::tags() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountStateResponse.tags)
  return tags_ != NULL ? *tags_ : *default_instance_->tags_;
}
inline ::bgs::protocol::account::v1::AccountFieldTags* GetAccountStateResponse::mutable_tags() {
  set_has_tags();
  if (tags_ == NULL) tags_ = new ::bgs::protocol::account::v1::AccountFieldTags;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountStateResponse.tags)
  return tags_;
}
inline ::bgs::protocol::account::v1::AccountFieldTags* GetAccountStateResponse::release_tags() {
  clear_has_tags();
  ::bgs::protocol::account::v1::AccountFieldTags* temp = tags_;
  tags_ = NULL;
  return temp;
}
inline void GetAccountStateResponse::set_allocated_tags(::bgs::protocol::account::v1::AccountFieldTags* tags) {
  delete tags_;
  tags_ = tags;
  if (tags) {
    set_has_tags();
  } else {
    clear_has_tags();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountStateResponse.tags)
}
 
// -------------------------------------------------------------------
 
// GetSignedAccountStateRequest
 
// optional .bgs.protocol.account.v1.AccountId account = 1;
inline bool GetSignedAccountStateRequest::has_account() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetSignedAccountStateRequest::set_has_account() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetSignedAccountStateRequest::clear_has_account() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetSignedAccountStateRequest::clear_account() {
  if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
  clear_has_account();
}
inline const ::bgs::protocol::account::v1::AccountId& GetSignedAccountStateRequest::account() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetSignedAccountStateRequest.account)
  return account_ != NULL ? *account_ : *default_instance_->account_;
}
inline ::bgs::protocol::account::v1::AccountId* GetSignedAccountStateRequest::mutable_account() {
  set_has_account();
  if (account_ == NULL) account_ = new ::bgs::protocol::account::v1::AccountId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetSignedAccountStateRequest.account)
  return account_;
}
inline ::bgs::protocol::account::v1::AccountId* GetSignedAccountStateRequest::release_account() {
  clear_has_account();
  ::bgs::protocol::account::v1::AccountId* temp = account_;
  account_ = NULL;
  return temp;
}
inline void GetSignedAccountStateRequest::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.GetSignedAccountStateRequest.account)
}
 
// -------------------------------------------------------------------
 
// GetSignedAccountStateResponse
 
// optional string token = 1;
inline bool GetSignedAccountStateResponse::has_token() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetSignedAccountStateResponse::set_has_token() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetSignedAccountStateResponse::clear_has_token() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetSignedAccountStateResponse::clear_token() {
  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    token_->clear();
  }
  clear_has_token();
}
inline const ::std::string& GetSignedAccountStateResponse::token() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetSignedAccountStateResponse.token)
  return *token_;
}
inline void GetSignedAccountStateResponse::set_token(const ::std::string& value) {
  set_has_token();
  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    token_ = new ::std::string;
  }
  token_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetSignedAccountStateResponse.token)
}
inline void GetSignedAccountStateResponse::set_token(const char* value) {
  set_has_token();
  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    token_ = new ::std::string;
  }
  token_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GetSignedAccountStateResponse.token)
}
inline void GetSignedAccountStateResponse::set_token(const char* value, size_t size) {
  set_has_token();
  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    token_ = new ::std::string;
  }
  token_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GetSignedAccountStateResponse.token)
}
inline ::std::string* GetSignedAccountStateResponse::mutable_token() {
  set_has_token();
  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    token_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetSignedAccountStateResponse.token)
  return token_;
}
inline ::std::string* GetSignedAccountStateResponse::release_token() {
  clear_has_token();
  if (token_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = token_;
    token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void GetSignedAccountStateResponse::set_allocated_token(::std::string* token) {
  if (token_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete token_;
  }
  if (token) {
    set_has_token();
    token_ = token;
  } else {
    clear_has_token();
    token_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetSignedAccountStateResponse.token)
}
 
// -------------------------------------------------------------------
 
// GetGameAccountStateRequest
 
// optional .bgs.protocol.EntityId account_id = 1 [deprecated = true];
inline bool GetGameAccountStateRequest::has_account_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetGameAccountStateRequest::set_has_account_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetGameAccountStateRequest::clear_has_account_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetGameAccountStateRequest::clear_account_id() {
  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
  clear_has_account_id();
}
inline const ::bgs::protocol::EntityId& GetGameAccountStateRequest::account_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateRequest.account_id)
  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
}
inline ::bgs::protocol::EntityId* GetGameAccountStateRequest::mutable_account_id() {
  set_has_account_id();
  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateRequest.account_id)
  return account_id_;
}
inline ::bgs::protocol::EntityId* GetGameAccountStateRequest::release_account_id() {
  clear_has_account_id();
  ::bgs::protocol::EntityId* temp = account_id_;
  account_id_ = NULL;
  return temp;
}
inline void GetGameAccountStateRequest::set_allocated_account_id(::bgs::protocol::EntityId* account_id) {
  delete account_id_;
  account_id_ = account_id;
  if (account_id) {
    set_has_account_id();
  } else {
    clear_has_account_id();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountStateRequest.account_id)
}
 
// optional .bgs.protocol.EntityId game_account_id = 2;
inline bool GetGameAccountStateRequest::has_game_account_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetGameAccountStateRequest::set_has_game_account_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetGameAccountStateRequest::clear_has_game_account_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetGameAccountStateRequest::clear_game_account_id() {
  if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
  clear_has_game_account_id();
}
inline const ::bgs::protocol::EntityId& GetGameAccountStateRequest::game_account_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateRequest.game_account_id)
  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
}
inline ::bgs::protocol::EntityId* GetGameAccountStateRequest::mutable_game_account_id() {
  set_has_game_account_id();
  if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateRequest.game_account_id)
  return game_account_id_;
}
inline ::bgs::protocol::EntityId* GetGameAccountStateRequest::release_game_account_id() {
  clear_has_game_account_id();
  ::bgs::protocol::EntityId* temp = game_account_id_;
  game_account_id_ = NULL;
  return temp;
}
inline void GetGameAccountStateRequest::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) {
  delete game_account_id_;
  game_account_id_ = game_account_id;
  if (game_account_id) {
    set_has_game_account_id();
  } else {
    clear_has_game_account_id();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountStateRequest.game_account_id)
}
 
// optional .bgs.protocol.account.v1.GameAccountFieldOptions options = 10;
inline bool GetGameAccountStateRequest::has_options() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GetGameAccountStateRequest::set_has_options() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GetGameAccountStateRequest::clear_has_options() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GetGameAccountStateRequest::clear_options() {
  if (options_ != NULL) options_->::bgs::protocol::account::v1::GameAccountFieldOptions::Clear();
  clear_has_options();
}
inline const ::bgs::protocol::account::v1::GameAccountFieldOptions& GetGameAccountStateRequest::options() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateRequest.options)
  return options_ != NULL ? *options_ : *default_instance_->options_;
}
inline ::bgs::protocol::account::v1::GameAccountFieldOptions* GetGameAccountStateRequest::mutable_options() {
  set_has_options();
  if (options_ == NULL) options_ = new ::bgs::protocol::account::v1::GameAccountFieldOptions;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateRequest.options)
  return options_;
}
inline ::bgs::protocol::account::v1::GameAccountFieldOptions* GetGameAccountStateRequest::release_options() {
  clear_has_options();
  ::bgs::protocol::account::v1::GameAccountFieldOptions* temp = options_;
  options_ = NULL;
  return temp;
}
inline void GetGameAccountStateRequest::set_allocated_options(::bgs::protocol::account::v1::GameAccountFieldOptions* options) {
  delete options_;
  options_ = options;
  if (options) {
    set_has_options();
  } else {
    clear_has_options();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountStateRequest.options)
}
 
// optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 11;
inline bool GetGameAccountStateRequest::has_tags() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void GetGameAccountStateRequest::set_has_tags() {
  _has_bits_[0] |= 0x00000008u;
}
inline void GetGameAccountStateRequest::clear_has_tags() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void GetGameAccountStateRequest::clear_tags() {
  if (tags_ != NULL) tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear();
  clear_has_tags();
}
inline const ::bgs::protocol::account::v1::GameAccountFieldTags& GetGameAccountStateRequest::tags() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateRequest.tags)
  return tags_ != NULL ? *tags_ : *default_instance_->tags_;
}
inline ::bgs::protocol::account::v1::GameAccountFieldTags* GetGameAccountStateRequest::mutable_tags() {
  set_has_tags();
  if (tags_ == NULL) tags_ = new ::bgs::protocol::account::v1::GameAccountFieldTags;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateRequest.tags)
  return tags_;
}
inline ::bgs::protocol::account::v1::GameAccountFieldTags* GetGameAccountStateRequest::release_tags() {
  clear_has_tags();
  ::bgs::protocol::account::v1::GameAccountFieldTags* temp = tags_;
  tags_ = NULL;
  return temp;
}
inline void GetGameAccountStateRequest::set_allocated_tags(::bgs::protocol::account::v1::GameAccountFieldTags* tags) {
  delete tags_;
  tags_ = tags;
  if (tags) {
    set_has_tags();
  } else {
    clear_has_tags();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountStateRequest.tags)
}
 
// -------------------------------------------------------------------
 
// GetGameAccountStateResponse
 
// optional .bgs.protocol.account.v1.GameAccountState state = 1;
inline bool GetGameAccountStateResponse::has_state() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetGameAccountStateResponse::set_has_state() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetGameAccountStateResponse::clear_has_state() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetGameAccountStateResponse::clear_state() {
  if (state_ != NULL) state_->::bgs::protocol::account::v1::GameAccountState::Clear();
  clear_has_state();
}
inline const ::bgs::protocol::account::v1::GameAccountState& GetGameAccountStateResponse::state() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateResponse.state)
  return state_ != NULL ? *state_ : *default_instance_->state_;
}
inline ::bgs::protocol::account::v1::GameAccountState* GetGameAccountStateResponse::mutable_state() {
  set_has_state();
  if (state_ == NULL) state_ = new ::bgs::protocol::account::v1::GameAccountState;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateResponse.state)
  return state_;
}
inline ::bgs::protocol::account::v1::GameAccountState* GetGameAccountStateResponse::release_state() {
  clear_has_state();
  ::bgs::protocol::account::v1::GameAccountState* temp = state_;
  state_ = NULL;
  return temp;
}
inline void GetGameAccountStateResponse::set_allocated_state(::bgs::protocol::account::v1::GameAccountState* state) {
  delete state_;
  state_ = state;
  if (state) {
    set_has_state();
  } else {
    clear_has_state();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountStateResponse.state)
}
 
// optional .bgs.protocol.account.v1.GameAccountFieldTags tags = 2;
inline bool GetGameAccountStateResponse::has_tags() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetGameAccountStateResponse::set_has_tags() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetGameAccountStateResponse::clear_has_tags() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetGameAccountStateResponse::clear_tags() {
  if (tags_ != NULL) tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear();
  clear_has_tags();
}
inline const ::bgs::protocol::account::v1::GameAccountFieldTags& GetGameAccountStateResponse::tags() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameAccountStateResponse.tags)
  return tags_ != NULL ? *tags_ : *default_instance_->tags_;
}
inline ::bgs::protocol::account::v1::GameAccountFieldTags* GetGameAccountStateResponse::mutable_tags() {
  set_has_tags();
  if (tags_ == NULL) tags_ = new ::bgs::protocol::account::v1::GameAccountFieldTags;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameAccountStateResponse.tags)
  return tags_;
}
inline ::bgs::protocol::account::v1::GameAccountFieldTags* GetGameAccountStateResponse::release_tags() {
  clear_has_tags();
  ::bgs::protocol::account::v1::GameAccountFieldTags* temp = tags_;
  tags_ = NULL;
  return temp;
}
inline void GetGameAccountStateResponse::set_allocated_tags(::bgs::protocol::account::v1::GameAccountFieldTags* tags) {
  delete tags_;
  tags_ = tags;
  if (tags) {
    set_has_tags();
  } else {
    clear_has_tags();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameAccountStateResponse.tags)
}
 
// -------------------------------------------------------------------
 
// GetLicensesRequest
 
// optional .bgs.protocol.EntityId target_id = 1;
inline bool GetLicensesRequest::has_target_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetLicensesRequest::set_has_target_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetLicensesRequest::clear_has_target_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetLicensesRequest::clear_target_id() {
  if (target_id_ != NULL) target_id_->::bgs::protocol::EntityId::Clear();
  clear_has_target_id();
}
inline const ::bgs::protocol::EntityId& GetLicensesRequest::target_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.target_id)
  return target_id_ != NULL ? *target_id_ : *default_instance_->target_id_;
}
inline ::bgs::protocol::EntityId* GetLicensesRequest::mutable_target_id() {
  set_has_target_id();
  if (target_id_ == NULL) target_id_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetLicensesRequest.target_id)
  return target_id_;
}
inline ::bgs::protocol::EntityId* GetLicensesRequest::release_target_id() {
  clear_has_target_id();
  ::bgs::protocol::EntityId* temp = target_id_;
  target_id_ = NULL;
  return temp;
}
inline void GetLicensesRequest::set_allocated_target_id(::bgs::protocol::EntityId* target_id) {
  delete target_id_;
  target_id_ = target_id;
  if (target_id) {
    set_has_target_id();
  } else {
    clear_has_target_id();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetLicensesRequest.target_id)
}
 
// optional bool fetch_account_licenses = 2;
inline bool GetLicensesRequest::has_fetch_account_licenses() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetLicensesRequest::set_has_fetch_account_licenses() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetLicensesRequest::clear_has_fetch_account_licenses() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetLicensesRequest::clear_fetch_account_licenses() {
  fetch_account_licenses_ = false;
  clear_has_fetch_account_licenses();
}
inline bool GetLicensesRequest::fetch_account_licenses() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.fetch_account_licenses)
  return fetch_account_licenses_;
}
inline void GetLicensesRequest::set_fetch_account_licenses(bool value) {
  set_has_fetch_account_licenses();
  fetch_account_licenses_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetLicensesRequest.fetch_account_licenses)
}
 
// optional bool fetch_game_account_licenses = 3;
inline bool GetLicensesRequest::has_fetch_game_account_licenses() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GetLicensesRequest::set_has_fetch_game_account_licenses() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GetLicensesRequest::clear_has_fetch_game_account_licenses() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GetLicensesRequest::clear_fetch_game_account_licenses() {
  fetch_game_account_licenses_ = false;
  clear_has_fetch_game_account_licenses();
}
inline bool GetLicensesRequest::fetch_game_account_licenses() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.fetch_game_account_licenses)
  return fetch_game_account_licenses_;
}
inline void GetLicensesRequest::set_fetch_game_account_licenses(bool value) {
  set_has_fetch_game_account_licenses();
  fetch_game_account_licenses_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetLicensesRequest.fetch_game_account_licenses)
}
 
// optional bool fetch_dynamic_account_licenses = 4;
inline bool GetLicensesRequest::has_fetch_dynamic_account_licenses() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void GetLicensesRequest::set_has_fetch_dynamic_account_licenses() {
  _has_bits_[0] |= 0x00000008u;
}
inline void GetLicensesRequest::clear_has_fetch_dynamic_account_licenses() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void GetLicensesRequest::clear_fetch_dynamic_account_licenses() {
  fetch_dynamic_account_licenses_ = false;
  clear_has_fetch_dynamic_account_licenses();
}
inline bool GetLicensesRequest::fetch_dynamic_account_licenses() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.fetch_dynamic_account_licenses)
  return fetch_dynamic_account_licenses_;
}
inline void GetLicensesRequest::set_fetch_dynamic_account_licenses(bool value) {
  set_has_fetch_dynamic_account_licenses();
  fetch_dynamic_account_licenses_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetLicensesRequest.fetch_dynamic_account_licenses)
}
 
// optional fixed32 program = 5;
inline bool GetLicensesRequest::has_program() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void GetLicensesRequest::set_has_program() {
  _has_bits_[0] |= 0x00000010u;
}
inline void GetLicensesRequest::clear_has_program() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void GetLicensesRequest::clear_program() {
  program_ = 0u;
  clear_has_program();
}
inline ::google::protobuf::uint32 GetLicensesRequest::program() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.program)
  return program_;
}
inline void GetLicensesRequest::set_program(::google::protobuf::uint32 value) {
  set_has_program();
  program_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetLicensesRequest.program)
}
 
// optional bool exclude_unknown_program = 6 [default = false];
inline bool GetLicensesRequest::has_exclude_unknown_program() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void GetLicensesRequest::set_has_exclude_unknown_program() {
  _has_bits_[0] |= 0x00000020u;
}
inline void GetLicensesRequest::clear_has_exclude_unknown_program() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void GetLicensesRequest::clear_exclude_unknown_program() {
  exclude_unknown_program_ = false;
  clear_has_exclude_unknown_program();
}
inline bool GetLicensesRequest::exclude_unknown_program() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesRequest.exclude_unknown_program)
  return exclude_unknown_program_;
}
inline void GetLicensesRequest::set_exclude_unknown_program(bool value) {
  set_has_exclude_unknown_program();
  exclude_unknown_program_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetLicensesRequest.exclude_unknown_program)
}
 
// -------------------------------------------------------------------
 
// GetLicensesResponse
 
// repeated .bgs.protocol.account.v1.AccountLicense licenses = 1;
inline int GetLicensesResponse::licenses_size() const {
  return licenses_.size();
}
inline void GetLicensesResponse::clear_licenses() {
  licenses_.Clear();
}
inline const ::bgs::protocol::account::v1::AccountLicense& GetLicensesResponse::licenses(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetLicensesResponse.licenses)
  return licenses_.Get(index);
}
inline ::bgs::protocol::account::v1::AccountLicense* GetLicensesResponse::mutable_licenses(int index) {
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetLicensesResponse.licenses)
  return licenses_.Mutable(index);
}
inline ::bgs::protocol::account::v1::AccountLicense* GetLicensesResponse::add_licenses() {
  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GetLicensesResponse.licenses)
  return licenses_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >&
GetLicensesResponse::licenses() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GetLicensesResponse.licenses)
  return licenses_;
}
inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AccountLicense >*
GetLicensesResponse::mutable_licenses() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GetLicensesResponse.licenses)
  return &licenses_;
}
 
// -------------------------------------------------------------------
 
// GetGameSessionInfoRequest
 
// optional .bgs.protocol.EntityId entity_id = 1;
inline bool GetGameSessionInfoRequest::has_entity_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetGameSessionInfoRequest::set_has_entity_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetGameSessionInfoRequest::clear_has_entity_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetGameSessionInfoRequest::clear_entity_id() {
  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
  clear_has_entity_id();
}
inline const ::bgs::protocol::EntityId& GetGameSessionInfoRequest::entity_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameSessionInfoRequest.entity_id)
  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
}
inline ::bgs::protocol::EntityId* GetGameSessionInfoRequest::mutable_entity_id() {
  set_has_entity_id();
  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameSessionInfoRequest.entity_id)
  return entity_id_;
}
inline ::bgs::protocol::EntityId* GetGameSessionInfoRequest::release_entity_id() {
  clear_has_entity_id();
  ::bgs::protocol::EntityId* temp = entity_id_;
  entity_id_ = NULL;
  return temp;
}
inline void GetGameSessionInfoRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
  delete entity_id_;
  entity_id_ = entity_id;
  if (entity_id) {
    set_has_entity_id();
  } else {
    clear_has_entity_id();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameSessionInfoRequest.entity_id)
}
 
// -------------------------------------------------------------------
 
// GetGameSessionInfoResponse
 
// optional .bgs.protocol.account.v1.GameSessionInfo session_info = 2;
inline bool GetGameSessionInfoResponse::has_session_info() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetGameSessionInfoResponse::set_has_session_info() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetGameSessionInfoResponse::clear_has_session_info() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetGameSessionInfoResponse::clear_session_info() {
  if (session_info_ != NULL) session_info_->::bgs::protocol::account::v1::GameSessionInfo::Clear();
  clear_has_session_info();
}
inline const ::bgs::protocol::account::v1::GameSessionInfo& GetGameSessionInfoResponse::session_info() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameSessionInfoResponse.session_info)
  return session_info_ != NULL ? *session_info_ : *default_instance_->session_info_;
}
inline ::bgs::protocol::account::v1::GameSessionInfo* GetGameSessionInfoResponse::mutable_session_info() {
  set_has_session_info();
  if (session_info_ == NULL) session_info_ = new ::bgs::protocol::account::v1::GameSessionInfo;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameSessionInfoResponse.session_info)
  return session_info_;
}
inline ::bgs::protocol::account::v1::GameSessionInfo* GetGameSessionInfoResponse::release_session_info() {
  clear_has_session_info();
  ::bgs::protocol::account::v1::GameSessionInfo* temp = session_info_;
  session_info_ = NULL;
  return temp;
}
inline void GetGameSessionInfoResponse::set_allocated_session_info(::bgs::protocol::account::v1::GameSessionInfo* session_info) {
  delete session_info_;
  session_info_ = session_info;
  if (session_info) {
    set_has_session_info();
  } else {
    clear_has_session_info();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameSessionInfoResponse.session_info)
}
 
// -------------------------------------------------------------------
 
// GetGameTimeRemainingInfoRequest
 
// optional .bgs.protocol.EntityId game_account_id = 1;
inline bool GetGameTimeRemainingInfoRequest::has_game_account_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetGameTimeRemainingInfoRequest::set_has_game_account_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetGameTimeRemainingInfoRequest::clear_has_game_account_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetGameTimeRemainingInfoRequest::clear_game_account_id() {
  if (game_account_id_ != NULL) game_account_id_->::bgs::protocol::EntityId::Clear();
  clear_has_game_account_id();
}
inline const ::bgs::protocol::EntityId& GetGameTimeRemainingInfoRequest::game_account_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.game_account_id)
  return game_account_id_ != NULL ? *game_account_id_ : *default_instance_->game_account_id_;
}
inline ::bgs::protocol::EntityId* GetGameTimeRemainingInfoRequest::mutable_game_account_id() {
  set_has_game_account_id();
  if (game_account_id_ == NULL) game_account_id_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.game_account_id)
  return game_account_id_;
}
inline ::bgs::protocol::EntityId* GetGameTimeRemainingInfoRequest::release_game_account_id() {
  clear_has_game_account_id();
  ::bgs::protocol::EntityId* temp = game_account_id_;
  game_account_id_ = NULL;
  return temp;
}
inline void GetGameTimeRemainingInfoRequest::set_allocated_game_account_id(::bgs::protocol::EntityId* game_account_id) {
  delete game_account_id_;
  game_account_id_ = game_account_id;
  if (game_account_id) {
    set_has_game_account_id();
  } else {
    clear_has_game_account_id();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.game_account_id)
}
 
// optional .bgs.protocol.EntityId account_id = 2;
inline bool GetGameTimeRemainingInfoRequest::has_account_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GetGameTimeRemainingInfoRequest::set_has_account_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GetGameTimeRemainingInfoRequest::clear_has_account_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GetGameTimeRemainingInfoRequest::clear_account_id() {
  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
  clear_has_account_id();
}
inline const ::bgs::protocol::EntityId& GetGameTimeRemainingInfoRequest::account_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.account_id)
  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
}
inline ::bgs::protocol::EntityId* GetGameTimeRemainingInfoRequest::mutable_account_id() {
  set_has_account_id();
  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.account_id)
  return account_id_;
}
inline ::bgs::protocol::EntityId* GetGameTimeRemainingInfoRequest::release_account_id() {
  clear_has_account_id();
  ::bgs::protocol::EntityId* temp = account_id_;
  account_id_ = NULL;
  return temp;
}
inline void GetGameTimeRemainingInfoRequest::set_allocated_account_id(::bgs::protocol::EntityId* account_id) {
  delete account_id_;
  account_id_ = account_id;
  if (account_id) {
    set_has_account_id();
  } else {
    clear_has_account_id();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.account_id)
}
 
// optional string benefactor_id = 3;
inline bool GetGameTimeRemainingInfoRequest::has_benefactor_id() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GetGameTimeRemainingInfoRequest::set_has_benefactor_id() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GetGameTimeRemainingInfoRequest::clear_has_benefactor_id() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GetGameTimeRemainingInfoRequest::clear_benefactor_id() {
  if (benefactor_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    benefactor_id_->clear();
  }
  clear_has_benefactor_id();
}
inline const ::std::string& GetGameTimeRemainingInfoRequest::benefactor_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.benefactor_id)
  return *benefactor_id_;
}
inline void GetGameTimeRemainingInfoRequest::set_benefactor_id(const ::std::string& value) {
  set_has_benefactor_id();
  if (benefactor_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    benefactor_id_ = new ::std::string;
  }
  benefactor_id_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.benefactor_id)
}
inline void GetGameTimeRemainingInfoRequest::set_benefactor_id(const char* value) {
  set_has_benefactor_id();
  if (benefactor_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    benefactor_id_ = new ::std::string;
  }
  benefactor_id_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.benefactor_id)
}
inline void GetGameTimeRemainingInfoRequest::set_benefactor_id(const char* value, size_t size) {
  set_has_benefactor_id();
  if (benefactor_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    benefactor_id_ = new ::std::string;
  }
  benefactor_id_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.benefactor_id)
}
inline ::std::string* GetGameTimeRemainingInfoRequest::mutable_benefactor_id() {
  set_has_benefactor_id();
  if (benefactor_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    benefactor_id_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.benefactor_id)
  return benefactor_id_;
}
inline ::std::string* GetGameTimeRemainingInfoRequest::release_benefactor_id() {
  clear_has_benefactor_id();
  if (benefactor_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = benefactor_id_;
    benefactor_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void GetGameTimeRemainingInfoRequest::set_allocated_benefactor_id(::std::string* benefactor_id) {
  if (benefactor_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete benefactor_id_;
  }
  if (benefactor_id) {
    set_has_benefactor_id();
    benefactor_id_ = benefactor_id;
  } else {
    clear_has_benefactor_id();
    benefactor_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameTimeRemainingInfoRequest.benefactor_id)
}
 
// -------------------------------------------------------------------
 
// GetGameTimeRemainingInfoResponse
 
// optional .bgs.protocol.account.v1.GameTimeRemainingInfo game_time_remaining_info = 1;
inline bool GetGameTimeRemainingInfoResponse::has_game_time_remaining_info() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetGameTimeRemainingInfoResponse::set_has_game_time_remaining_info() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetGameTimeRemainingInfoResponse::clear_has_game_time_remaining_info() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetGameTimeRemainingInfoResponse::clear_game_time_remaining_info() {
  if (game_time_remaining_info_ != NULL) game_time_remaining_info_->::bgs::protocol::account::v1::GameTimeRemainingInfo::Clear();
  clear_has_game_time_remaining_info();
}
inline const ::bgs::protocol::account::v1::GameTimeRemainingInfo& GetGameTimeRemainingInfoResponse::game_time_remaining_info() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse.game_time_remaining_info)
  return game_time_remaining_info_ != NULL ? *game_time_remaining_info_ : *default_instance_->game_time_remaining_info_;
}
inline ::bgs::protocol::account::v1::GameTimeRemainingInfo* GetGameTimeRemainingInfoResponse::mutable_game_time_remaining_info() {
  set_has_game_time_remaining_info();
  if (game_time_remaining_info_ == NULL) game_time_remaining_info_ = new ::bgs::protocol::account::v1::GameTimeRemainingInfo;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse.game_time_remaining_info)
  return game_time_remaining_info_;
}
inline ::bgs::protocol::account::v1::GameTimeRemainingInfo* GetGameTimeRemainingInfoResponse::release_game_time_remaining_info() {
  clear_has_game_time_remaining_info();
  ::bgs::protocol::account::v1::GameTimeRemainingInfo* temp = game_time_remaining_info_;
  game_time_remaining_info_ = NULL;
  return temp;
}
inline void GetGameTimeRemainingInfoResponse::set_allocated_game_time_remaining_info(::bgs::protocol::account::v1::GameTimeRemainingInfo* game_time_remaining_info) {
  delete game_time_remaining_info_;
  game_time_remaining_info_ = game_time_remaining_info;
  if (game_time_remaining_info) {
    set_has_game_time_remaining_info();
  } else {
    clear_has_game_time_remaining_info();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetGameTimeRemainingInfoResponse.game_time_remaining_info)
}
 
// -------------------------------------------------------------------
 
// GetCAISInfoRequest
 
// optional .bgs.protocol.EntityId entity_id = 1;
inline bool GetCAISInfoRequest::has_entity_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetCAISInfoRequest::set_has_entity_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetCAISInfoRequest::clear_has_entity_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetCAISInfoRequest::clear_entity_id() {
  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
  clear_has_entity_id();
}
inline const ::bgs::protocol::EntityId& GetCAISInfoRequest::entity_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetCAISInfoRequest.entity_id)
  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
}
inline ::bgs::protocol::EntityId* GetCAISInfoRequest::mutable_entity_id() {
  set_has_entity_id();
  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetCAISInfoRequest.entity_id)
  return entity_id_;
}
inline ::bgs::protocol::EntityId* GetCAISInfoRequest::release_entity_id() {
  clear_has_entity_id();
  ::bgs::protocol::EntityId* temp = entity_id_;
  entity_id_ = NULL;
  return temp;
}
inline void GetCAISInfoRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
  delete entity_id_;
  entity_id_ = entity_id;
  if (entity_id) {
    set_has_entity_id();
  } else {
    clear_has_entity_id();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetCAISInfoRequest.entity_id)
}
 
// -------------------------------------------------------------------
 
// GetCAISInfoResponse
 
// optional .bgs.protocol.account.v1.CAIS cais_info = 1;
inline bool GetCAISInfoResponse::has_cais_info() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetCAISInfoResponse::set_has_cais_info() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetCAISInfoResponse::clear_has_cais_info() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetCAISInfoResponse::clear_cais_info() {
  if (cais_info_ != NULL) cais_info_->::bgs::protocol::account::v1::CAIS::Clear();
  clear_has_cais_info();
}
inline const ::bgs::protocol::account::v1::CAIS& GetCAISInfoResponse::cais_info() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetCAISInfoResponse.cais_info)
  return cais_info_ != NULL ? *cais_info_ : *default_instance_->cais_info_;
}
inline ::bgs::protocol::account::v1::CAIS* GetCAISInfoResponse::mutable_cais_info() {
  set_has_cais_info();
  if (cais_info_ == NULL) cais_info_ = new ::bgs::protocol::account::v1::CAIS;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetCAISInfoResponse.cais_info)
  return cais_info_;
}
inline ::bgs::protocol::account::v1::CAIS* GetCAISInfoResponse::release_cais_info() {
  clear_has_cais_info();
  ::bgs::protocol::account::v1::CAIS* temp = cais_info_;
  cais_info_ = NULL;
  return temp;
}
inline void GetCAISInfoResponse::set_allocated_cais_info(::bgs::protocol::account::v1::CAIS* cais_info) {
  delete cais_info_;
  cais_info_ = cais_info;
  if (cais_info) {
    set_has_cais_info();
  } else {
    clear_has_cais_info();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetCAISInfoResponse.cais_info)
}
 
// -------------------------------------------------------------------
 
// GetAuthorizedDataRequest
 
// optional .bgs.protocol.EntityId entity_id = 1;
inline bool GetAuthorizedDataRequest::has_entity_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetAuthorizedDataRequest::set_has_entity_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetAuthorizedDataRequest::clear_has_entity_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetAuthorizedDataRequest::clear_entity_id() {
  if (entity_id_ != NULL) entity_id_->::bgs::protocol::EntityId::Clear();
  clear_has_entity_id();
}
inline const ::bgs::protocol::EntityId& GetAuthorizedDataRequest::entity_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAuthorizedDataRequest.entity_id)
  return entity_id_ != NULL ? *entity_id_ : *default_instance_->entity_id_;
}
inline ::bgs::protocol::EntityId* GetAuthorizedDataRequest::mutable_entity_id() {
  set_has_entity_id();
  if (entity_id_ == NULL) entity_id_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAuthorizedDataRequest.entity_id)
  return entity_id_;
}
inline ::bgs::protocol::EntityId* GetAuthorizedDataRequest::release_entity_id() {
  clear_has_entity_id();
  ::bgs::protocol::EntityId* temp = entity_id_;
  entity_id_ = NULL;
  return temp;
}
inline void GetAuthorizedDataRequest::set_allocated_entity_id(::bgs::protocol::EntityId* entity_id) {
  delete entity_id_;
  entity_id_ = entity_id;
  if (entity_id) {
    set_has_entity_id();
  } else {
    clear_has_entity_id();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAuthorizedDataRequest.entity_id)
}
 
// repeated string tag = 2;
inline int GetAuthorizedDataRequest::tag_size() const {
  return tag_.size();
}
inline void GetAuthorizedDataRequest::clear_tag() {
  tag_.Clear();
}
inline const ::std::string& GetAuthorizedDataRequest::tag(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
  return tag_.Get(index);
}
inline ::std::string* GetAuthorizedDataRequest::mutable_tag(int index) {
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
  return tag_.Mutable(index);
}
inline void GetAuthorizedDataRequest::set_tag(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
  tag_.Mutable(index)->assign(value);
}
inline void GetAuthorizedDataRequest::set_tag(int index, const char* value) {
  tag_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
}
inline void GetAuthorizedDataRequest::set_tag(int index, const char* value, size_t size) {
  tag_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
}
inline ::std::string* GetAuthorizedDataRequest::add_tag() {
  return tag_.Add();
}
inline void GetAuthorizedDataRequest::add_tag(const ::std::string& value) {
  tag_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
}
inline void GetAuthorizedDataRequest::add_tag(const char* value) {
  tag_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
}
inline void GetAuthorizedDataRequest::add_tag(const char* value, size_t size) {
  tag_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
GetAuthorizedDataRequest::tag() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
  return tag_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
GetAuthorizedDataRequest::mutable_tag() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GetAuthorizedDataRequest.tag)
  return &tag_;
}
 
// optional bool privileged_network = 3;
inline bool GetAuthorizedDataRequest::has_privileged_network() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GetAuthorizedDataRequest::set_has_privileged_network() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GetAuthorizedDataRequest::clear_has_privileged_network() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GetAuthorizedDataRequest::clear_privileged_network() {
  privileged_network_ = false;
  clear_has_privileged_network();
}
inline bool GetAuthorizedDataRequest::privileged_network() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAuthorizedDataRequest.privileged_network)
  return privileged_network_;
}
inline void GetAuthorizedDataRequest::set_privileged_network(bool value) {
  set_has_privileged_network();
  privileged_network_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GetAuthorizedDataRequest.privileged_network)
}
 
// -------------------------------------------------------------------
 
// GetAuthorizedDataResponse
 
// repeated .bgs.protocol.account.v1.AuthorizedData data = 1;
inline int GetAuthorizedDataResponse::data_size() const {
  return data_.size();
}
inline void GetAuthorizedDataResponse::clear_data() {
  data_.Clear();
}
inline const ::bgs::protocol::account::v1::AuthorizedData& GetAuthorizedDataResponse::data(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAuthorizedDataResponse.data)
  return data_.Get(index);
}
inline ::bgs::protocol::account::v1::AuthorizedData* GetAuthorizedDataResponse::mutable_data(int index) {
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAuthorizedDataResponse.data)
  return data_.Mutable(index);
}
inline ::bgs::protocol::account::v1::AuthorizedData* GetAuthorizedDataResponse::add_data() {
  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GetAuthorizedDataResponse.data)
  return data_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AuthorizedData >&
GetAuthorizedDataResponse::data() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GetAuthorizedDataResponse.data)
  return data_;
}
inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::AuthorizedData >*
GetAuthorizedDataResponse::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GetAuthorizedDataResponse.data)
  return &data_;
}
 
// -------------------------------------------------------------------
 
// GetAccountInfoRequest
 
// optional .bgs.protocol.EntityId account_id = 1;
inline bool GetAccountInfoRequest::has_account_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetAccountInfoRequest::set_has_account_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetAccountInfoRequest::clear_has_account_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetAccountInfoRequest::clear_account_id() {
  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
  clear_has_account_id();
}
inline const ::bgs::protocol::EntityId& GetAccountInfoRequest::account_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountInfoRequest.account_id)
  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
}
inline ::bgs::protocol::EntityId* GetAccountInfoRequest::mutable_account_id() {
  set_has_account_id();
  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountInfoRequest.account_id)
  return account_id_;
}
inline ::bgs::protocol::EntityId* GetAccountInfoRequest::release_account_id() {
  clear_has_account_id();
  ::bgs::protocol::EntityId* temp = account_id_;
  account_id_ = NULL;
  return temp;
}
inline void GetAccountInfoRequest::set_allocated_account_id(::bgs::protocol::EntityId* account_id) {
  delete account_id_;
  account_id_ = account_id;
  if (account_id) {
    set_has_account_id();
  } else {
    clear_has_account_id();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountInfoRequest.account_id)
}
 
// -------------------------------------------------------------------
 
// GetAccountInfoResponse
 
// optional .bgs.protocol.account.v1.AccountInfo account_info = 1;
inline bool GetAccountInfoResponse::has_account_info() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetAccountInfoResponse::set_has_account_info() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetAccountInfoResponse::clear_has_account_info() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetAccountInfoResponse::clear_account_info() {
  if (account_info_ != NULL) account_info_->::bgs::protocol::account::v1::AccountInfo::Clear();
  clear_has_account_info();
}
inline const ::bgs::protocol::account::v1::AccountInfo& GetAccountInfoResponse::account_info() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountInfoResponse.account_info)
  return account_info_ != NULL ? *account_info_ : *default_instance_->account_info_;
}
inline ::bgs::protocol::account::v1::AccountInfo* GetAccountInfoResponse::mutable_account_info() {
  set_has_account_info();
  if (account_info_ == NULL) account_info_ = new ::bgs::protocol::account::v1::AccountInfo;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountInfoResponse.account_info)
  return account_info_;
}
inline ::bgs::protocol::account::v1::AccountInfo* GetAccountInfoResponse::release_account_info() {
  clear_has_account_info();
  ::bgs::protocol::account::v1::AccountInfo* temp = account_info_;
  account_info_ = NULL;
  return temp;
}
inline void GetAccountInfoResponse::set_allocated_account_info(::bgs::protocol::account::v1::AccountInfo* account_info) {
  delete account_info_;
  account_info_ = account_info;
  if (account_info) {
    set_has_account_info();
  } else {
    clear_has_account_info();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountInfoResponse.account_info)
}
 
// -------------------------------------------------------------------
 
// GetAccountPlatformRestrictionsRequest
 
// optional .bgs.protocol.EntityId account_id = 1;
inline bool GetAccountPlatformRestrictionsRequest::has_account_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetAccountPlatformRestrictionsRequest::set_has_account_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetAccountPlatformRestrictionsRequest::clear_has_account_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetAccountPlatformRestrictionsRequest::clear_account_id() {
  if (account_id_ != NULL) account_id_->::bgs::protocol::EntityId::Clear();
  clear_has_account_id();
}
inline const ::bgs::protocol::EntityId& GetAccountPlatformRestrictionsRequest::account_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountPlatformRestrictionsRequest.account_id)
  return account_id_ != NULL ? *account_id_ : *default_instance_->account_id_;
}
inline ::bgs::protocol::EntityId* GetAccountPlatformRestrictionsRequest::mutable_account_id() {
  set_has_account_id();
  if (account_id_ == NULL) account_id_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountPlatformRestrictionsRequest.account_id)
  return account_id_;
}
inline ::bgs::protocol::EntityId* GetAccountPlatformRestrictionsRequest::release_account_id() {
  clear_has_account_id();
  ::bgs::protocol::EntityId* temp = account_id_;
  account_id_ = NULL;
  return temp;
}
inline void GetAccountPlatformRestrictionsRequest::set_allocated_account_id(::bgs::protocol::EntityId* account_id) {
  delete account_id_;
  account_id_ = account_id;
  if (account_id) {
    set_has_account_id();
  } else {
    clear_has_account_id();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountPlatformRestrictionsRequest.account_id)
}
 
// -------------------------------------------------------------------
 
// GetAccountPlatformRestrictionsResponse
 
// optional .bgs.protocol.account.v1.AccountPlatformRestrictionInfo restriction_info = 1;
inline bool GetAccountPlatformRestrictionsResponse::has_restriction_info() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GetAccountPlatformRestrictionsResponse::set_has_restriction_info() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GetAccountPlatformRestrictionsResponse::clear_has_restriction_info() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GetAccountPlatformRestrictionsResponse::clear_restriction_info() {
  if (restriction_info_ != NULL) restriction_info_->::bgs::protocol::account::v1::AccountPlatformRestrictionInfo::Clear();
  clear_has_restriction_info();
}
inline const ::bgs::protocol::account::v1::AccountPlatformRestrictionInfo& GetAccountPlatformRestrictionsResponse::restriction_info() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GetAccountPlatformRestrictionsResponse.restriction_info)
  return restriction_info_ != NULL ? *restriction_info_ : *default_instance_->restriction_info_;
}
inline ::bgs::protocol::account::v1::AccountPlatformRestrictionInfo* GetAccountPlatformRestrictionsResponse::mutable_restriction_info() {
  set_has_restriction_info();
  if (restriction_info_ == NULL) restriction_info_ = new ::bgs::protocol::account::v1::AccountPlatformRestrictionInfo;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GetAccountPlatformRestrictionsResponse.restriction_info)
  return restriction_info_;
}
inline ::bgs::protocol::account::v1::AccountPlatformRestrictionInfo* GetAccountPlatformRestrictionsResponse::release_restriction_info() {
  clear_has_restriction_info();
  ::bgs::protocol::account::v1::AccountPlatformRestrictionInfo* temp = restriction_info_;
  restriction_info_ = NULL;
  return temp;
}
inline void GetAccountPlatformRestrictionsResponse::set_allocated_restriction_info(::bgs::protocol::account::v1::AccountPlatformRestrictionInfo* restriction_info) {
  delete restriction_info_;
  restriction_info_ = restriction_info;
  if (restriction_info) {
    set_has_restriction_info();
  } else {
    clear_has_restriction_info();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GetAccountPlatformRestrictionsResponse.restriction_info)
}
 
// -------------------------------------------------------------------
 
// AccountStateNotification
 
// optional .bgs.protocol.account.v1.AccountState account_state = 1;
inline bool AccountStateNotification::has_account_state() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AccountStateNotification::set_has_account_state() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AccountStateNotification::clear_has_account_state() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AccountStateNotification::clear_account_state() {
  if (account_state_ != NULL) account_state_->::bgs::protocol::account::v1::AccountState::Clear();
  clear_has_account_state();
}
inline const ::bgs::protocol::account::v1::AccountState& AccountStateNotification::account_state() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountStateNotification.account_state)
  return account_state_ != NULL ? *account_state_ : *default_instance_->account_state_;
}
inline ::bgs::protocol::account::v1::AccountState* AccountStateNotification::mutable_account_state() {
  set_has_account_state();
  if (account_state_ == NULL) account_state_ = new ::bgs::protocol::account::v1::AccountState;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountStateNotification.account_state)
  return account_state_;
}
inline ::bgs::protocol::account::v1::AccountState* AccountStateNotification::release_account_state() {
  clear_has_account_state();
  ::bgs::protocol::account::v1::AccountState* temp = account_state_;
  account_state_ = NULL;
  return temp;
}
inline void AccountStateNotification::set_allocated_account_state(::bgs::protocol::account::v1::AccountState* account_state) {
  delete account_state_;
  account_state_ = account_state;
  if (account_state) {
    set_has_account_state();
  } else {
    clear_has_account_state();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountStateNotification.account_state)
}
 
// optional uint64 subscriber_id = 2 [deprecated = true];
inline bool AccountStateNotification::has_subscriber_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void AccountStateNotification::set_has_subscriber_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void AccountStateNotification::clear_has_subscriber_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void AccountStateNotification::clear_subscriber_id() {
  subscriber_id_ = GOOGLE_ULONGLONG(0);
  clear_has_subscriber_id();
}
inline ::google::protobuf::uint64 AccountStateNotification::subscriber_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountStateNotification.subscriber_id)
  return subscriber_id_;
}
inline void AccountStateNotification::set_subscriber_id(::google::protobuf::uint64 value) {
  set_has_subscriber_id();
  subscriber_id_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountStateNotification.subscriber_id)
}
 
// optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
inline bool AccountStateNotification::has_account_tags() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void AccountStateNotification::set_has_account_tags() {
  _has_bits_[0] |= 0x00000004u;
}
inline void AccountStateNotification::clear_has_account_tags() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void AccountStateNotification::clear_account_tags() {
  if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear();
  clear_has_account_tags();
}
inline const ::bgs::protocol::account::v1::AccountFieldTags& AccountStateNotification::account_tags() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountStateNotification.account_tags)
  return account_tags_ != NULL ? *account_tags_ : *default_instance_->account_tags_;
}
inline ::bgs::protocol::account::v1::AccountFieldTags* AccountStateNotification::mutable_account_tags() {
  set_has_account_tags();
  if (account_tags_ == NULL) account_tags_ = new ::bgs::protocol::account::v1::AccountFieldTags;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.AccountStateNotification.account_tags)
  return account_tags_;
}
inline ::bgs::protocol::account::v1::AccountFieldTags* AccountStateNotification::release_account_tags() {
  clear_has_account_tags();
  ::bgs::protocol::account::v1::AccountFieldTags* temp = account_tags_;
  account_tags_ = NULL;
  return temp;
}
inline void AccountStateNotification::set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags) {
  delete account_tags_;
  account_tags_ = account_tags;
  if (account_tags) {
    set_has_account_tags();
  } else {
    clear_has_account_tags();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.AccountStateNotification.account_tags)
}
 
// optional bool subscription_completed = 4;
inline bool AccountStateNotification::has_subscription_completed() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void AccountStateNotification::set_has_subscription_completed() {
  _has_bits_[0] |= 0x00000008u;
}
inline void AccountStateNotification::clear_has_subscription_completed() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void AccountStateNotification::clear_subscription_completed() {
  subscription_completed_ = false;
  clear_has_subscription_completed();
}
inline bool AccountStateNotification::subscription_completed() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.AccountStateNotification.subscription_completed)
  return subscription_completed_;
}
inline void AccountStateNotification::set_subscription_completed(bool value) {
  set_has_subscription_completed();
  subscription_completed_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.AccountStateNotification.subscription_completed)
}
 
// -------------------------------------------------------------------
 
// GameAccountStateNotification
 
// optional .bgs.protocol.account.v1.GameAccountState game_account_state = 1;
inline bool GameAccountStateNotification::has_game_account_state() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GameAccountStateNotification::set_has_game_account_state() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GameAccountStateNotification::clear_has_game_account_state() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GameAccountStateNotification::clear_game_account_state() {
  if (game_account_state_ != NULL) game_account_state_->::bgs::protocol::account::v1::GameAccountState::Clear();
  clear_has_game_account_state();
}
inline const ::bgs::protocol::account::v1::GameAccountState& GameAccountStateNotification::game_account_state() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountStateNotification.game_account_state)
  return game_account_state_ != NULL ? *game_account_state_ : *default_instance_->game_account_state_;
}
inline ::bgs::protocol::account::v1::GameAccountState* GameAccountStateNotification::mutable_game_account_state() {
  set_has_game_account_state();
  if (game_account_state_ == NULL) game_account_state_ = new ::bgs::protocol::account::v1::GameAccountState;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountStateNotification.game_account_state)
  return game_account_state_;
}
inline ::bgs::protocol::account::v1::GameAccountState* GameAccountStateNotification::release_game_account_state() {
  clear_has_game_account_state();
  ::bgs::protocol::account::v1::GameAccountState* temp = game_account_state_;
  game_account_state_ = NULL;
  return temp;
}
inline void GameAccountStateNotification::set_allocated_game_account_state(::bgs::protocol::account::v1::GameAccountState* game_account_state) {
  delete game_account_state_;
  game_account_state_ = game_account_state;
  if (game_account_state) {
    set_has_game_account_state();
  } else {
    clear_has_game_account_state();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountStateNotification.game_account_state)
}
 
// optional uint64 subscriber_id = 2 [deprecated = true];
inline bool GameAccountStateNotification::has_subscriber_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GameAccountStateNotification::set_has_subscriber_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GameAccountStateNotification::clear_has_subscriber_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GameAccountStateNotification::clear_subscriber_id() {
  subscriber_id_ = GOOGLE_ULONGLONG(0);
  clear_has_subscriber_id();
}
inline ::google::protobuf::uint64 GameAccountStateNotification::subscriber_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountStateNotification.subscriber_id)
  return subscriber_id_;
}
inline void GameAccountStateNotification::set_subscriber_id(::google::protobuf::uint64 value) {
  set_has_subscriber_id();
  subscriber_id_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountStateNotification.subscriber_id)
}
 
// optional .bgs.protocol.account.v1.GameAccountFieldTags game_account_tags = 3;
inline bool GameAccountStateNotification::has_game_account_tags() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GameAccountStateNotification::set_has_game_account_tags() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GameAccountStateNotification::clear_has_game_account_tags() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GameAccountStateNotification::clear_game_account_tags() {
  if (game_account_tags_ != NULL) game_account_tags_->::bgs::protocol::account::v1::GameAccountFieldTags::Clear();
  clear_has_game_account_tags();
}
inline const ::bgs::protocol::account::v1::GameAccountFieldTags& GameAccountStateNotification::game_account_tags() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountStateNotification.game_account_tags)
  return game_account_tags_ != NULL ? *game_account_tags_ : *default_instance_->game_account_tags_;
}
inline ::bgs::protocol::account::v1::GameAccountFieldTags* GameAccountStateNotification::mutable_game_account_tags() {
  set_has_game_account_tags();
  if (game_account_tags_ == NULL) game_account_tags_ = new ::bgs::protocol::account::v1::GameAccountFieldTags;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountStateNotification.game_account_tags)
  return game_account_tags_;
}
inline ::bgs::protocol::account::v1::GameAccountFieldTags* GameAccountStateNotification::release_game_account_tags() {
  clear_has_game_account_tags();
  ::bgs::protocol::account::v1::GameAccountFieldTags* temp = game_account_tags_;
  game_account_tags_ = NULL;
  return temp;
}
inline void GameAccountStateNotification::set_allocated_game_account_tags(::bgs::protocol::account::v1::GameAccountFieldTags* game_account_tags) {
  delete game_account_tags_;
  game_account_tags_ = game_account_tags;
  if (game_account_tags) {
    set_has_game_account_tags();
  } else {
    clear_has_game_account_tags();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountStateNotification.game_account_tags)
}
 
// optional bool subscription_completed = 4;
inline bool GameAccountStateNotification::has_subscription_completed() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void GameAccountStateNotification::set_has_subscription_completed() {
  _has_bits_[0] |= 0x00000008u;
}
inline void GameAccountStateNotification::clear_has_subscription_completed() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void GameAccountStateNotification::clear_subscription_completed() {
  subscription_completed_ = false;
  clear_has_subscription_completed();
}
inline bool GameAccountStateNotification::subscription_completed() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountStateNotification.subscription_completed)
  return subscription_completed_;
}
inline void GameAccountStateNotification::set_subscription_completed(bool value) {
  set_has_subscription_completed();
  subscription_completed_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountStateNotification.subscription_completed)
}
 
// -------------------------------------------------------------------
 
// GameAccountNotification
 
// repeated .bgs.protocol.account.v1.GameAccountList game_accounts = 1;
inline int GameAccountNotification::game_accounts_size() const {
  return game_accounts_.size();
}
inline void GameAccountNotification::clear_game_accounts() {
  game_accounts_.Clear();
}
inline const ::bgs::protocol::account::v1::GameAccountList& GameAccountNotification::game_accounts(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountNotification.game_accounts)
  return game_accounts_.Get(index);
}
inline ::bgs::protocol::account::v1::GameAccountList* GameAccountNotification::mutable_game_accounts(int index) {
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountNotification.game_accounts)
  return game_accounts_.Mutable(index);
}
inline ::bgs::protocol::account::v1::GameAccountList* GameAccountNotification::add_game_accounts() {
  // @@protoc_insertion_point(field_add:bgs.protocol.account.v1.GameAccountNotification.game_accounts)
  return game_accounts_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >&
GameAccountNotification::game_accounts() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.account.v1.GameAccountNotification.game_accounts)
  return game_accounts_;
}
inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::account::v1::GameAccountList >*
GameAccountNotification::mutable_game_accounts() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.account.v1.GameAccountNotification.game_accounts)
  return &game_accounts_;
}
 
// optional uint64 subscriber_id = 2;
inline bool GameAccountNotification::has_subscriber_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GameAccountNotification::set_has_subscriber_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GameAccountNotification::clear_has_subscriber_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GameAccountNotification::clear_subscriber_id() {
  subscriber_id_ = GOOGLE_ULONGLONG(0);
  clear_has_subscriber_id();
}
inline ::google::protobuf::uint64 GameAccountNotification::subscriber_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountNotification.subscriber_id)
  return subscriber_id_;
}
inline void GameAccountNotification::set_subscriber_id(::google::protobuf::uint64 value) {
  set_has_subscriber_id();
  subscriber_id_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.account.v1.GameAccountNotification.subscriber_id)
}
 
// optional .bgs.protocol.account.v1.AccountFieldTags account_tags = 3;
inline bool GameAccountNotification::has_account_tags() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void GameAccountNotification::set_has_account_tags() {
  _has_bits_[0] |= 0x00000004u;
}
inline void GameAccountNotification::clear_has_account_tags() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void GameAccountNotification::clear_account_tags() {
  if (account_tags_ != NULL) account_tags_->::bgs::protocol::account::v1::AccountFieldTags::Clear();
  clear_has_account_tags();
}
inline const ::bgs::protocol::account::v1::AccountFieldTags& GameAccountNotification::account_tags() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountNotification.account_tags)
  return account_tags_ != NULL ? *account_tags_ : *default_instance_->account_tags_;
}
inline ::bgs::protocol::account::v1::AccountFieldTags* GameAccountNotification::mutable_account_tags() {
  set_has_account_tags();
  if (account_tags_ == NULL) account_tags_ = new ::bgs::protocol::account::v1::AccountFieldTags;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountNotification.account_tags)
  return account_tags_;
}
inline ::bgs::protocol::account::v1::AccountFieldTags* GameAccountNotification::release_account_tags() {
  clear_has_account_tags();
  ::bgs::protocol::account::v1::AccountFieldTags* temp = account_tags_;
  account_tags_ = NULL;
  return temp;
}
inline void GameAccountNotification::set_allocated_account_tags(::bgs::protocol::account::v1::AccountFieldTags* account_tags) {
  delete account_tags_;
  account_tags_ = account_tags;
  if (account_tags) {
    set_has_account_tags();
  } else {
    clear_has_account_tags();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountNotification.account_tags)
}
 
// -------------------------------------------------------------------
 
// GameAccountSessionNotification
 
// optional .bgs.protocol.account.v1.GameAccountHandle game_account = 1;
inline bool GameAccountSessionNotification::has_game_account() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GameAccountSessionNotification::set_has_game_account() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GameAccountSessionNotification::clear_has_game_account() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GameAccountSessionNotification::clear_game_account() {
  if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
  clear_has_game_account();
}
inline const ::bgs::protocol::account::v1::GameAccountHandle& GameAccountSessionNotification::game_account() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountSessionNotification.game_account)
  return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountSessionNotification::mutable_game_account() {
  set_has_game_account();
  if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountSessionNotification.game_account)
  return game_account_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* GameAccountSessionNotification::release_game_account() {
  clear_has_game_account();
  ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_;
  game_account_ = NULL;
  return temp;
}
inline void GameAccountSessionNotification::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) {
  delete game_account_;
  game_account_ = game_account;
  if (game_account) {
    set_has_game_account();
  } else {
    clear_has_game_account();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountSessionNotification.game_account)
}
 
// optional .bgs.protocol.account.v1.GameSessionUpdateInfo session_info = 2;
inline bool GameAccountSessionNotification::has_session_info() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void GameAccountSessionNotification::set_has_session_info() {
  _has_bits_[0] |= 0x00000002u;
}
inline void GameAccountSessionNotification::clear_has_session_info() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void GameAccountSessionNotification::clear_session_info() {
  if (session_info_ != NULL) session_info_->::bgs::protocol::account::v1::GameSessionUpdateInfo::Clear();
  clear_has_session_info();
}
inline const ::bgs::protocol::account::v1::GameSessionUpdateInfo& GameAccountSessionNotification::session_info() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.account.v1.GameAccountSessionNotification.session_info)
  return session_info_ != NULL ? *session_info_ : *default_instance_->session_info_;
}
inline ::bgs::protocol::account::v1::GameSessionUpdateInfo* GameAccountSessionNotification::mutable_session_info() {
  set_has_session_info();
  if (session_info_ == NULL) session_info_ = new ::bgs::protocol::account::v1::GameSessionUpdateInfo;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.account.v1.GameAccountSessionNotification.session_info)
  return session_info_;
}
inline ::bgs::protocol::account::v1::GameSessionUpdateInfo* GameAccountSessionNotification::release_session_info() {
  clear_has_session_info();
  ::bgs::protocol::account::v1::GameSessionUpdateInfo* temp = session_info_;
  session_info_ = NULL;
  return temp;
}
inline void GameAccountSessionNotification::set_allocated_session_info(::bgs::protocol::account::v1::GameSessionUpdateInfo* session_info) {
  delete session_info_;
  session_info_ = session_info;
  if (session_info) {
    set_has_session_info();
  } else {
    clear_has_session_info();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.account.v1.GameAccountSessionNotification.session_info)
}
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace v1
}  // namespace account
}  // namespace protocol
}  // namespace bgs
 
#ifndef SWIG
namespace google {
namespace protobuf {
}  // namespace google
}  // namespace protobuf
#endif  // SWIG
 
// @@protoc_insertion_point(global_scope)
 
#endif  // PROTOBUF_account_5fservice_2eproto__INCLUDED