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

#ifndef PROTOBUF_report_5ftypes_2eproto__INCLUDED
#define PROTOBUF_report_5ftypes_2eproto__INCLUDED

#include <string>

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

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

#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "account_types.pb.h"
#include "attribute_types.pb.h"
#include "entity_types.pb.h"
#include "rpc_types.pb.h"
#include "Define.h" // for TC_PROTO_API
// @@protoc_insertion_point(includes)

namespace bgs {
namespace protocol {
namespace report {
namespace v1 {

// Internal implementation detail -- do not call these.
void TC_PROTO_API protobuf_AddDesc_report_5ftypes_2eproto();
void protobuf_AssignDesc_report_5ftypes_2eproto();
void protobuf_ShutdownFile_report_5ftypes_2eproto();

class ReportType;
class CustomReport;
class SpamReport;
class HarassmentReport;
class RealLifeThreatReport;
class InappropriateBattleTagReport;
class HackingReport;
class BottingReport;
class Report;

enum SpamReport_SpamSource {
  SpamReport_SpamSource_OTHER = 1,
  SpamReport_SpamSource_FRIEND_INVITATION = 2,
  SpamReport_SpamSource_WHISPER = 3,
  SpamReport_SpamSource_CHAT = 4
};
TC_PROTO_API bool SpamReport_SpamSource_IsValid(int value);
const SpamReport_SpamSource SpamReport_SpamSource_SpamSource_MIN = SpamReport_SpamSource_OTHER;
const SpamReport_SpamSource SpamReport_SpamSource_SpamSource_MAX = SpamReport_SpamSource_CHAT;
const int SpamReport_SpamSource_SpamSource_ARRAYSIZE = SpamReport_SpamSource_SpamSource_MAX + 1;

TC_PROTO_API const ::google::protobuf::EnumDescriptor* SpamReport_SpamSource_descriptor();
inline const ::std::string& SpamReport_SpamSource_Name(SpamReport_SpamSource value) {
  return ::google::protobuf::internal::NameOfEnum(
    SpamReport_SpamSource_descriptor(), value);
}
inline bool SpamReport_SpamSource_Parse(
    const ::std::string& name, SpamReport_SpamSource* value) {
  return ::google::protobuf::internal::ParseNamedEnum<SpamReport_SpamSource>(
    SpamReport_SpamSource_descriptor(), name, value);
}
// ===================================================================

class TC_PROTO_API ReportType : public ::google::protobuf::Message {
 public:
  ReportType();
  virtual ~ReportType();

  ReportType(const ReportType& from);

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

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

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

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

  enum TypeCase {
    kCustomReport = 10,
    kSpamReport = 11,
    kHarassmentReport = 12,
    kRealLifeThreatReport = 13,
    kInappropriateBattleTagReport = 14,
    kHackingReport = 15,
    kBottingReport = 16,
    TYPE_NOT_SET = 0,
  };

  void Swap(ReportType* other);

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

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

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

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

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

  // optional string user_description = 1;
  inline bool has_user_description() const;
  inline void clear_user_description();
  static const int kUserDescriptionFieldNumber = 1;
  inline const ::std::string& user_description() const;
  inline void set_user_description(const ::std::string& value);
  inline void set_user_description(const char* value);
  inline void set_user_description(const char* value, size_t size);
  inline ::std::string* mutable_user_description();
  inline ::std::string* release_user_description();
  inline void set_allocated_user_description(::std::string* user_description);

  // optional .bgs.protocol.report.v1.CustomReport custom_report = 10;
  inline bool has_custom_report() const;
  inline void clear_custom_report();
  static const int kCustomReportFieldNumber = 10;
  inline const ::bgs::protocol::report::v1::CustomReport& custom_report() const;
  inline ::bgs::protocol::report::v1::CustomReport* mutable_custom_report();
  inline ::bgs::protocol::report::v1::CustomReport* release_custom_report();
  inline void set_allocated_custom_report(::bgs::protocol::report::v1::CustomReport* custom_report);

  // optional .bgs.protocol.report.v1.SpamReport spam_report = 11;
  inline bool has_spam_report() const;
  inline void clear_spam_report();
  static const int kSpamReportFieldNumber = 11;
  inline const ::bgs::protocol::report::v1::SpamReport& spam_report() const;
  inline ::bgs::protocol::report::v1::SpamReport* mutable_spam_report();
  inline ::bgs::protocol::report::v1::SpamReport* release_spam_report();
  inline void set_allocated_spam_report(::bgs::protocol::report::v1::SpamReport* spam_report);

  // optional .bgs.protocol.report.v1.HarassmentReport harassment_report = 12;
  inline bool has_harassment_report() const;
  inline void clear_harassment_report();
  static const int kHarassmentReportFieldNumber = 12;
  inline const ::bgs::protocol::report::v1::HarassmentReport& harassment_report() const;
  inline ::bgs::protocol::report::v1::HarassmentReport* mutable_harassment_report();
  inline ::bgs::protocol::report::v1::HarassmentReport* release_harassment_report();
  inline void set_allocated_harassment_report(::bgs::protocol::report::v1::HarassmentReport* harassment_report);

  // optional .bgs.protocol.report.v1.RealLifeThreatReport real_life_threat_report = 13;
  inline bool has_real_life_threat_report() const;
  inline void clear_real_life_threat_report();
  static const int kRealLifeThreatReportFieldNumber = 13;
  inline const ::bgs::protocol::report::v1::RealLifeThreatReport& real_life_threat_report() const;
  inline ::bgs::protocol::report::v1::RealLifeThreatReport* mutable_real_life_threat_report();
  inline ::bgs::protocol::report::v1::RealLifeThreatReport* release_real_life_threat_report();
  inline void set_allocated_real_life_threat_report(::bgs::protocol::report::v1::RealLifeThreatReport* real_life_threat_report);

  // optional .bgs.protocol.report.v1.InappropriateBattleTagReport inappropriate_battle_tag_report = 14;
  inline bool has_inappropriate_battle_tag_report() const;
  inline void clear_inappropriate_battle_tag_report();
  static const int kInappropriateBattleTagReportFieldNumber = 14;
  inline const ::bgs::protocol::report::v1::InappropriateBattleTagReport& inappropriate_battle_tag_report() const;
  inline ::bgs::protocol::report::v1::InappropriateBattleTagReport* mutable_inappropriate_battle_tag_report();
  inline ::bgs::protocol::report::v1::InappropriateBattleTagReport* release_inappropriate_battle_tag_report();
  inline void set_allocated_inappropriate_battle_tag_report(::bgs::protocol::report::v1::InappropriateBattleTagReport* inappropriate_battle_tag_report);

  // optional .bgs.protocol.report.v1.HackingReport hacking_report = 15;
  inline bool has_hacking_report() const;
  inline void clear_hacking_report();
  static const int kHackingReportFieldNumber = 15;
  inline const ::bgs::protocol::report::v1::HackingReport& hacking_report() const;
  inline ::bgs::protocol::report::v1::HackingReport* mutable_hacking_report();
  inline ::bgs::protocol::report::v1::HackingReport* release_hacking_report();
  inline void set_allocated_hacking_report(::bgs::protocol::report::v1::HackingReport* hacking_report);

  // optional .bgs.protocol.report.v1.BottingReport botting_report = 16;
  inline bool has_botting_report() const;
  inline void clear_botting_report();
  static const int kBottingReportFieldNumber = 16;
  inline const ::bgs::protocol::report::v1::BottingReport& botting_report() const;
  inline ::bgs::protocol::report::v1::BottingReport* mutable_botting_report();
  inline ::bgs::protocol::report::v1::BottingReport* release_botting_report();
  inline void set_allocated_botting_report(::bgs::protocol::report::v1::BottingReport* botting_report);

  inline TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:bgs.protocol.report.v1.ReportType)
 private:
  inline void set_has_user_description();
  inline void clear_has_user_description();
  inline void set_has_custom_report();
  inline void set_has_spam_report();
  inline void set_has_harassment_report();
  inline void set_has_real_life_threat_report();
  inline void set_has_inappropriate_battle_tag_report();
  inline void set_has_hacking_report();
  inline void set_has_botting_report();

  inline bool has_type();
  void clear_type();
  inline void clear_has_type();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* user_description_;
  union TypeUnion {
    ::bgs::protocol::report::v1::CustomReport* custom_report_;
    ::bgs::protocol::report::v1::SpamReport* spam_report_;
    ::bgs::protocol::report::v1::HarassmentReport* harassment_report_;
    ::bgs::protocol::report::v1::RealLifeThreatReport* real_life_threat_report_;
    ::bgs::protocol::report::v1::InappropriateBattleTagReport* inappropriate_battle_tag_report_;
    ::bgs::protocol::report::v1::HackingReport* hacking_report_;
    ::bgs::protocol::report::v1::BottingReport* botting_report_;
  } type_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend void TC_PROTO_API protobuf_AddDesc_report_5ftypes_2eproto();
  friend void protobuf_AssignDesc_report_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_report_5ftypes_2eproto();

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

class TC_PROTO_API CustomReport : public ::google::protobuf::Message {
 public:
  CustomReport();
  virtual ~CustomReport();

  CustomReport(const CustomReport& from);

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

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

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

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

  void Swap(CustomReport* other);

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

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

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

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

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

  // optional string type = 1;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 1;
  inline const ::std::string& type() const;
  inline void set_type(const ::std::string& value);
  inline void set_type(const char* value);
  inline void set_type(const char* value, size_t size);
  inline ::std::string* mutable_type();
  inline ::std::string* release_type();
  inline void set_allocated_type(::std::string* type);

  // optional string program_id = 2 [deprecated = true];
  inline bool has_program_id() const PROTOBUF_DEPRECATED;
  inline void clear_program_id() PROTOBUF_DEPRECATED;
  static const int kProgramIdFieldNumber = 2;
  inline const ::std::string& program_id() const PROTOBUF_DEPRECATED;
  inline void set_program_id(const ::std::string& value) PROTOBUF_DEPRECATED;
  inline void set_program_id(const char* value) PROTOBUF_DEPRECATED;
  inline void set_program_id(const char* value, size_t size) PROTOBUF_DEPRECATED;
  inline ::std::string* mutable_program_id() PROTOBUF_DEPRECATED;
  inline ::std::string* release_program_id() PROTOBUF_DEPRECATED;
  inline void set_allocated_program_id(::std::string* program_id) PROTOBUF_DEPRECATED;

  // repeated .bgs.protocol.Attribute attribute = 3;
  inline int attribute_size() const;
  inline void clear_attribute();
  static const int kAttributeFieldNumber = 3;
  inline const ::bgs::protocol::Attribute& attribute(int index) const;
  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
  inline ::bgs::protocol::Attribute* add_attribute();
  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
      attribute() const;
  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
      mutable_attribute();

  // @@protoc_insertion_point(class_scope:bgs.protocol.report.v1.CustomReport)
 private:
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_program_id();
  inline void clear_has_program_id();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* type_;
  ::std::string* program_id_;
  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
  friend void TC_PROTO_API protobuf_AddDesc_report_5ftypes_2eproto();
  friend void protobuf_AssignDesc_report_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_report_5ftypes_2eproto();

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

class TC_PROTO_API SpamReport : public ::google::protobuf::Message {
 public:
  SpamReport();
  virtual ~SpamReport();

  SpamReport(const SpamReport& from);

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

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

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

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

  void Swap(SpamReport* other);

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

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

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

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

  typedef SpamReport_SpamSource SpamSource;
  static const SpamSource OTHER = SpamReport_SpamSource_OTHER;
  static const SpamSource FRIEND_INVITATION = SpamReport_SpamSource_FRIEND_INVITATION;
  static const SpamSource WHISPER = SpamReport_SpamSource_WHISPER;
  static const SpamSource CHAT = SpamReport_SpamSource_CHAT;
  static inline bool SpamSource_IsValid(int value) {
    return SpamReport_SpamSource_IsValid(value);
  }
  static const SpamSource SpamSource_MIN =
    SpamReport_SpamSource_SpamSource_MIN;
  static const SpamSource SpamSource_MAX =
    SpamReport_SpamSource_SpamSource_MAX;
  static const int SpamSource_ARRAYSIZE =
    SpamReport_SpamSource_SpamSource_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  SpamSource_descriptor() {
    return SpamReport_SpamSource_descriptor();
  }
  static inline const ::std::string& SpamSource_Name(SpamSource value) {
    return SpamReport_SpamSource_Name(value);
  }
  static inline bool SpamSource_Parse(const ::std::string& name,
      SpamSource* value) {
    return SpamReport_SpamSource_Parse(name, value);
  }

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

  // optional .bgs.protocol.account.v1.GameAccountHandle target = 1;
  inline bool has_target() const;
  inline void clear_target();
  static const int kTargetFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::GameAccountHandle& target() const;
  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_target();
  inline ::bgs::protocol::account::v1::GameAccountHandle* release_target();
  inline void set_allocated_target(::bgs::protocol::account::v1::GameAccountHandle* target);

  // optional .bgs.protocol.report.v1.SpamReport.SpamSource source = 2 [default = OTHER];
  inline bool has_source() const;
  inline void clear_source();
  static const int kSourceFieldNumber = 2;
  inline ::bgs::protocol::report::v1::SpamReport_SpamSource source() const;
  inline void set_source(::bgs::protocol::report::v1::SpamReport_SpamSource value);

  // @@protoc_insertion_point(class_scope:bgs.protocol.report.v1.SpamReport)
 private:
  inline void set_has_target();
  inline void clear_has_target();
  inline void set_has_source();
  inline void clear_has_source();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::GameAccountHandle* target_;
  int source_;
  friend void TC_PROTO_API protobuf_AddDesc_report_5ftypes_2eproto();
  friend void protobuf_AssignDesc_report_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_report_5ftypes_2eproto();

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

class TC_PROTO_API HarassmentReport : public ::google::protobuf::Message {
 public:
  HarassmentReport();
  virtual ~HarassmentReport();

  HarassmentReport(const HarassmentReport& from);

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

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

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

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

  void Swap(HarassmentReport* other);

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

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

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

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

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

  // optional .bgs.protocol.account.v1.GameAccountHandle target = 1;
  inline bool has_target() const;
  inline void clear_target();
  static const int kTargetFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::GameAccountHandle& target() const;
  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_target();
  inline ::bgs::protocol::account::v1::GameAccountHandle* release_target();
  inline void set_allocated_target(::bgs::protocol::account::v1::GameAccountHandle* target);

  // optional string text = 2;
  inline bool has_text() const;
  inline void clear_text();
  static const int kTextFieldNumber = 2;
  inline const ::std::string& text() const;
  inline void set_text(const ::std::string& value);
  inline void set_text(const char* value);
  inline void set_text(const char* value, size_t size);
  inline ::std::string* mutable_text();
  inline ::std::string* release_text();
  inline void set_allocated_text(::std::string* text);

  // @@protoc_insertion_point(class_scope:bgs.protocol.report.v1.HarassmentReport)
 private:
  inline void set_has_target();
  inline void clear_has_target();
  inline void set_has_text();
  inline void clear_has_text();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::GameAccountHandle* target_;
  ::std::string* text_;
  friend void TC_PROTO_API protobuf_AddDesc_report_5ftypes_2eproto();
  friend void protobuf_AssignDesc_report_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_report_5ftypes_2eproto();

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

class TC_PROTO_API RealLifeThreatReport : public ::google::protobuf::Message {
 public:
  RealLifeThreatReport();
  virtual ~RealLifeThreatReport();

  RealLifeThreatReport(const RealLifeThreatReport& from);

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

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

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

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

  void Swap(RealLifeThreatReport* other);

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

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

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

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

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

  // optional .bgs.protocol.account.v1.GameAccountHandle target = 1;
  inline bool has_target() const;
  inline void clear_target();
  static const int kTargetFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::GameAccountHandle& target() const;
  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_target();
  inline ::bgs::protocol::account::v1::GameAccountHandle* release_target();
  inline void set_allocated_target(::bgs::protocol::account::v1::GameAccountHandle* target);

  // optional string text = 2;
  inline bool has_text() const;
  inline void clear_text();
  static const int kTextFieldNumber = 2;
  inline const ::std::string& text() const;
  inline void set_text(const ::std::string& value);
  inline void set_text(const char* value);
  inline void set_text(const char* value, size_t size);
  inline ::std::string* mutable_text();
  inline ::std::string* release_text();
  inline void set_allocated_text(::std::string* text);

  // @@protoc_insertion_point(class_scope:bgs.protocol.report.v1.RealLifeThreatReport)
 private:
  inline void set_has_target();
  inline void clear_has_target();
  inline void set_has_text();
  inline void clear_has_text();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::GameAccountHandle* target_;
  ::std::string* text_;
  friend void TC_PROTO_API protobuf_AddDesc_report_5ftypes_2eproto();
  friend void protobuf_AssignDesc_report_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_report_5ftypes_2eproto();

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

class TC_PROTO_API InappropriateBattleTagReport : public ::google::protobuf::Message {
 public:
  InappropriateBattleTagReport();
  virtual ~InappropriateBattleTagReport();

  InappropriateBattleTagReport(const InappropriateBattleTagReport& from);

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

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

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

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

  void Swap(InappropriateBattleTagReport* other);

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

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

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

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

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

  // optional .bgs.protocol.account.v1.GameAccountHandle target = 1;
  inline bool has_target() const;
  inline void clear_target();
  static const int kTargetFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::GameAccountHandle& target() const;
  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_target();
  inline ::bgs::protocol::account::v1::GameAccountHandle* release_target();
  inline void set_allocated_target(::bgs::protocol::account::v1::GameAccountHandle* target);

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

  // @@protoc_insertion_point(class_scope:bgs.protocol.report.v1.InappropriateBattleTagReport)
 private:
  inline void set_has_target();
  inline void clear_has_target();
  inline void set_has_battle_tag();
  inline void clear_has_battle_tag();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::GameAccountHandle* target_;
  ::std::string* battle_tag_;
  friend void TC_PROTO_API protobuf_AddDesc_report_5ftypes_2eproto();
  friend void protobuf_AssignDesc_report_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_report_5ftypes_2eproto();

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

class TC_PROTO_API HackingReport : public ::google::protobuf::Message {
 public:
  HackingReport();
  virtual ~HackingReport();

  HackingReport(const HackingReport& from);

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

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

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

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

  void Swap(HackingReport* other);

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

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

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

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

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

  // optional .bgs.protocol.account.v1.GameAccountHandle target = 1;
  inline bool has_target() const;
  inline void clear_target();
  static const int kTargetFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::GameAccountHandle& target() const;
  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_target();
  inline ::bgs::protocol::account::v1::GameAccountHandle* release_target();
  inline void set_allocated_target(::bgs::protocol::account::v1::GameAccountHandle* target);

  // @@protoc_insertion_point(class_scope:bgs.protocol.report.v1.HackingReport)
 private:
  inline void set_has_target();
  inline void clear_has_target();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::GameAccountHandle* target_;
  friend void TC_PROTO_API protobuf_AddDesc_report_5ftypes_2eproto();
  friend void protobuf_AssignDesc_report_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_report_5ftypes_2eproto();

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

class TC_PROTO_API BottingReport : public ::google::protobuf::Message {
 public:
  BottingReport();
  virtual ~BottingReport();

  BottingReport(const BottingReport& from);

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

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

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

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

  void Swap(BottingReport* other);

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

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

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

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

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

  // optional .bgs.protocol.account.v1.GameAccountHandle target = 1;
  inline bool has_target() const;
  inline void clear_target();
  static const int kTargetFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::GameAccountHandle& target() const;
  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_target();
  inline ::bgs::protocol::account::v1::GameAccountHandle* release_target();
  inline void set_allocated_target(::bgs::protocol::account::v1::GameAccountHandle* target);

  // @@protoc_insertion_point(class_scope:bgs.protocol.report.v1.BottingReport)
 private:
  inline void set_has_target();
  inline void clear_has_target();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::GameAccountHandle* target_;
  friend void TC_PROTO_API protobuf_AddDesc_report_5ftypes_2eproto();
  friend void protobuf_AssignDesc_report_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_report_5ftypes_2eproto();

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

class TC_PROTO_API Report : public ::google::protobuf::Message {
 public:
  Report();
  virtual ~Report();

  Report(const Report& from);

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

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

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

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

  void Swap(Report* other);

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

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

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

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

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

  // required string report_type = 1;
  inline bool has_report_type() const;
  inline void clear_report_type();
  static const int kReportTypeFieldNumber = 1;
  inline const ::std::string& report_type() const;
  inline void set_report_type(const ::std::string& value);
  inline void set_report_type(const char* value);
  inline void set_report_type(const char* value, size_t size);
  inline ::std::string* mutable_report_type();
  inline ::std::string* release_report_type();
  inline void set_allocated_report_type(::std::string* report_type);

  // repeated .bgs.protocol.Attribute attribute = 2;
  inline int attribute_size() const;
  inline void clear_attribute();
  static const int kAttributeFieldNumber = 2;
  inline const ::bgs::protocol::Attribute& attribute(int index) const;
  inline ::bgs::protocol::Attribute* mutable_attribute(int index);
  inline ::bgs::protocol::Attribute* add_attribute();
  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
      attribute() const;
  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
      mutable_attribute();

  // optional int32 report_qos = 3 [default = 0];
  inline bool has_report_qos() const;
  inline void clear_report_qos();
  static const int kReportQosFieldNumber = 3;
  inline ::google::protobuf::int32 report_qos() const;
  inline void set_report_qos(::google::protobuf::int32 value);

  // optional .bgs.protocol.EntityId reporting_account = 4;
  inline bool has_reporting_account() const;
  inline void clear_reporting_account();
  static const int kReportingAccountFieldNumber = 4;
  inline const ::bgs::protocol::EntityId& reporting_account() const;
  inline ::bgs::protocol::EntityId* mutable_reporting_account();
  inline ::bgs::protocol::EntityId* release_reporting_account();
  inline void set_allocated_reporting_account(::bgs::protocol::EntityId* reporting_account);

  // optional .bgs.protocol.EntityId reporting_game_account = 5;
  inline bool has_reporting_game_account() const;
  inline void clear_reporting_game_account();
  static const int kReportingGameAccountFieldNumber = 5;
  inline const ::bgs::protocol::EntityId& reporting_game_account() const;
  inline ::bgs::protocol::EntityId* mutable_reporting_game_account();
  inline ::bgs::protocol::EntityId* release_reporting_game_account();
  inline void set_allocated_reporting_game_account(::bgs::protocol::EntityId* reporting_game_account);

  // optional fixed64 report_timestamp = 6;
  inline bool has_report_timestamp() const;
  inline void clear_report_timestamp();
  static const int kReportTimestampFieldNumber = 6;
  inline ::google::protobuf::uint64 report_timestamp() const;
  inline void set_report_timestamp(::google::protobuf::uint64 value);

  // @@protoc_insertion_point(class_scope:bgs.protocol.report.v1.Report)
 private:
  inline void set_has_report_type();
  inline void clear_has_report_type();
  inline void set_has_report_qos();
  inline void clear_has_report_qos();
  inline void set_has_reporting_account();
  inline void clear_has_reporting_account();
  inline void set_has_reporting_game_account();
  inline void clear_has_reporting_game_account();
  inline void set_has_report_timestamp();
  inline void clear_has_report_timestamp();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::std::string* report_type_;
  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
  ::bgs::protocol::EntityId* reporting_account_;
  ::bgs::protocol::EntityId* reporting_game_account_;
  ::google::protobuf::uint64 report_timestamp_;
  ::google::protobuf::int32 report_qos_;
  friend void TC_PROTO_API protobuf_AddDesc_report_5ftypes_2eproto();
  friend void protobuf_AssignDesc_report_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_report_5ftypes_2eproto();

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


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


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

// ReportType

// optional string user_description = 1;
inline bool ReportType::has_user_description() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReportType::set_has_user_description() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ReportType::clear_has_user_description() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ReportType::clear_user_description() {
  if (user_description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    user_description_->clear();
  }
  clear_has_user_description();
}
inline const ::std::string& ReportType::user_description() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.ReportType.user_description)
  return *user_description_;
}
inline void ReportType::set_user_description(const ::std::string& value) {
  set_has_user_description();
  if (user_description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    user_description_ = new ::std::string;
  }
  user_description_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.ReportType.user_description)
}
inline void ReportType::set_user_description(const char* value) {
  set_has_user_description();
  if (user_description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    user_description_ = new ::std::string;
  }
  user_description_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.report.v1.ReportType.user_description)
}
inline void ReportType::set_user_description(const char* value, size_t size) {
  set_has_user_description();
  if (user_description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    user_description_ = new ::std::string;
  }
  user_description_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.report.v1.ReportType.user_description)
}
inline ::std::string* ReportType::mutable_user_description() {
  set_has_user_description();
  if (user_description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    user_description_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.ReportType.user_description)
  return user_description_;
}
inline ::std::string* ReportType::release_user_description() {
  clear_has_user_description();
  if (user_description_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = user_description_;
    user_description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void ReportType::set_allocated_user_description(::std::string* user_description) {
  if (user_description_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete user_description_;
  }
  if (user_description) {
    set_has_user_description();
    user_description_ = user_description;
  } else {
    clear_has_user_description();
    user_description_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.ReportType.user_description)
}

// optional .bgs.protocol.report.v1.CustomReport custom_report = 10;
inline bool ReportType::has_custom_report() const {
  return type_case() == kCustomReport;
}
inline void ReportType::set_has_custom_report() {
  _oneof_case_[0] = kCustomReport;
}
inline void ReportType::clear_custom_report() {
  if (has_custom_report()) {
    delete type_.custom_report_;
    clear_has_type();
  }
}
inline const ::bgs::protocol::report::v1::CustomReport& ReportType::custom_report() const {
  return has_custom_report() ? *type_.custom_report_
                      : ::bgs::protocol::report::v1::CustomReport::default_instance();
}
inline ::bgs::protocol::report::v1::CustomReport* ReportType::mutable_custom_report() {
  if (!has_custom_report()) {
    clear_type();
    set_has_custom_report();
    type_.custom_report_ = new ::bgs::protocol::report::v1::CustomReport;
  }
  return type_.custom_report_;
}
inline ::bgs::protocol::report::v1::CustomReport* ReportType::release_custom_report() {
  if (has_custom_report()) {
    clear_has_type();
    ::bgs::protocol::report::v1::CustomReport* temp = type_.custom_report_;
    type_.custom_report_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void ReportType::set_allocated_custom_report(::bgs::protocol::report::v1::CustomReport* custom_report) {
  clear_type();
  if (custom_report) {
    set_has_custom_report();
    type_.custom_report_ = custom_report;
  }
}

// optional .bgs.protocol.report.v1.SpamReport spam_report = 11;
inline bool ReportType::has_spam_report() const {
  return type_case() == kSpamReport;
}
inline void ReportType::set_has_spam_report() {
  _oneof_case_[0] = kSpamReport;
}
inline void ReportType::clear_spam_report() {
  if (has_spam_report()) {
    delete type_.spam_report_;
    clear_has_type();
  }
}
inline const ::bgs::protocol::report::v1::SpamReport& ReportType::spam_report() const {
  return has_spam_report() ? *type_.spam_report_
                      : ::bgs::protocol::report::v1::SpamReport::default_instance();
}
inline ::bgs::protocol::report::v1::SpamReport* ReportType::mutable_spam_report() {
  if (!has_spam_report()) {
    clear_type();
    set_has_spam_report();
    type_.spam_report_ = new ::bgs::protocol::report::v1::SpamReport;
  }
  return type_.spam_report_;
}
inline ::bgs::protocol::report::v1::SpamReport* ReportType::release_spam_report() {
  if (has_spam_report()) {
    clear_has_type();
    ::bgs::protocol::report::v1::SpamReport* temp = type_.spam_report_;
    type_.spam_report_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void ReportType::set_allocated_spam_report(::bgs::protocol::report::v1::SpamReport* spam_report) {
  clear_type();
  if (spam_report) {
    set_has_spam_report();
    type_.spam_report_ = spam_report;
  }
}

// optional .bgs.protocol.report.v1.HarassmentReport harassment_report = 12;
inline bool ReportType::has_harassment_report() const {
  return type_case() == kHarassmentReport;
}
inline void ReportType::set_has_harassment_report() {
  _oneof_case_[0] = kHarassmentReport;
}
inline void ReportType::clear_harassment_report() {
  if (has_harassment_report()) {
    delete type_.harassment_report_;
    clear_has_type();
  }
}
inline const ::bgs::protocol::report::v1::HarassmentReport& ReportType::harassment_report() const {
  return has_harassment_report() ? *type_.harassment_report_
                      : ::bgs::protocol::report::v1::HarassmentReport::default_instance();
}
inline ::bgs::protocol::report::v1::HarassmentReport* ReportType::mutable_harassment_report() {
  if (!has_harassment_report()) {
    clear_type();
    set_has_harassment_report();
    type_.harassment_report_ = new ::bgs::protocol::report::v1::HarassmentReport;
  }
  return type_.harassment_report_;
}
inline ::bgs::protocol::report::v1::HarassmentReport* ReportType::release_harassment_report() {
  if (has_harassment_report()) {
    clear_has_type();
    ::bgs::protocol::report::v1::HarassmentReport* temp = type_.harassment_report_;
    type_.harassment_report_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void ReportType::set_allocated_harassment_report(::bgs::protocol::report::v1::HarassmentReport* harassment_report) {
  clear_type();
  if (harassment_report) {
    set_has_harassment_report();
    type_.harassment_report_ = harassment_report;
  }
}

// optional .bgs.protocol.report.v1.RealLifeThreatReport real_life_threat_report = 13;
inline bool ReportType::has_real_life_threat_report() const {
  return type_case() == kRealLifeThreatReport;
}
inline void ReportType::set_has_real_life_threat_report() {
  _oneof_case_[0] = kRealLifeThreatReport;
}
inline void ReportType::clear_real_life_threat_report() {
  if (has_real_life_threat_report()) {
    delete type_.real_life_threat_report_;
    clear_has_type();
  }
}
inline const ::bgs::protocol::report::v1::RealLifeThreatReport& ReportType::real_life_threat_report() const {
  return has_real_life_threat_report() ? *type_.real_life_threat_report_
                      : ::bgs::protocol::report::v1::RealLifeThreatReport::default_instance();
}
inline ::bgs::protocol::report::v1::RealLifeThreatReport* ReportType::mutable_real_life_threat_report() {
  if (!has_real_life_threat_report()) {
    clear_type();
    set_has_real_life_threat_report();
    type_.real_life_threat_report_ = new ::bgs::protocol::report::v1::RealLifeThreatReport;
  }
  return type_.real_life_threat_report_;
}
inline ::bgs::protocol::report::v1::RealLifeThreatReport* ReportType::release_real_life_threat_report() {
  if (has_real_life_threat_report()) {
    clear_has_type();
    ::bgs::protocol::report::v1::RealLifeThreatReport* temp = type_.real_life_threat_report_;
    type_.real_life_threat_report_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void ReportType::set_allocated_real_life_threat_report(::bgs::protocol::report::v1::RealLifeThreatReport* real_life_threat_report) {
  clear_type();
  if (real_life_threat_report) {
    set_has_real_life_threat_report();
    type_.real_life_threat_report_ = real_life_threat_report;
  }
}

// optional .bgs.protocol.report.v1.InappropriateBattleTagReport inappropriate_battle_tag_report = 14;
inline bool ReportType::has_inappropriate_battle_tag_report() const {
  return type_case() == kInappropriateBattleTagReport;
}
inline void ReportType::set_has_inappropriate_battle_tag_report() {
  _oneof_case_[0] = kInappropriateBattleTagReport;
}
inline void ReportType::clear_inappropriate_battle_tag_report() {
  if (has_inappropriate_battle_tag_report()) {
    delete type_.inappropriate_battle_tag_report_;
    clear_has_type();
  }
}
inline const ::bgs::protocol::report::v1::InappropriateBattleTagReport& ReportType::inappropriate_battle_tag_report() const {
  return has_inappropriate_battle_tag_report() ? *type_.inappropriate_battle_tag_report_
                      : ::bgs::protocol::report::v1::InappropriateBattleTagReport::default_instance();
}
inline ::bgs::protocol::report::v1::InappropriateBattleTagReport* ReportType::mutable_inappropriate_battle_tag_report() {
  if (!has_inappropriate_battle_tag_report()) {
    clear_type();
    set_has_inappropriate_battle_tag_report();
    type_.inappropriate_battle_tag_report_ = new ::bgs::protocol::report::v1::InappropriateBattleTagReport;
  }
  return type_.inappropriate_battle_tag_report_;
}
inline ::bgs::protocol::report::v1::InappropriateBattleTagReport* ReportType::release_inappropriate_battle_tag_report() {
  if (has_inappropriate_battle_tag_report()) {
    clear_has_type();
    ::bgs::protocol::report::v1::InappropriateBattleTagReport* temp = type_.inappropriate_battle_tag_report_;
    type_.inappropriate_battle_tag_report_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void ReportType::set_allocated_inappropriate_battle_tag_report(::bgs::protocol::report::v1::InappropriateBattleTagReport* inappropriate_battle_tag_report) {
  clear_type();
  if (inappropriate_battle_tag_report) {
    set_has_inappropriate_battle_tag_report();
    type_.inappropriate_battle_tag_report_ = inappropriate_battle_tag_report;
  }
}

// optional .bgs.protocol.report.v1.HackingReport hacking_report = 15;
inline bool ReportType::has_hacking_report() const {
  return type_case() == kHackingReport;
}
inline void ReportType::set_has_hacking_report() {
  _oneof_case_[0] = kHackingReport;
}
inline void ReportType::clear_hacking_report() {
  if (has_hacking_report()) {
    delete type_.hacking_report_;
    clear_has_type();
  }
}
inline const ::bgs::protocol::report::v1::HackingReport& ReportType::hacking_report() const {
  return has_hacking_report() ? *type_.hacking_report_
                      : ::bgs::protocol::report::v1::HackingReport::default_instance();
}
inline ::bgs::protocol::report::v1::HackingReport* ReportType::mutable_hacking_report() {
  if (!has_hacking_report()) {
    clear_type();
    set_has_hacking_report();
    type_.hacking_report_ = new ::bgs::protocol::report::v1::HackingReport;
  }
  return type_.hacking_report_;
}
inline ::bgs::protocol::report::v1::HackingReport* ReportType::release_hacking_report() {
  if (has_hacking_report()) {
    clear_has_type();
    ::bgs::protocol::report::v1::HackingReport* temp = type_.hacking_report_;
    type_.hacking_report_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void ReportType::set_allocated_hacking_report(::bgs::protocol::report::v1::HackingReport* hacking_report) {
  clear_type();
  if (hacking_report) {
    set_has_hacking_report();
    type_.hacking_report_ = hacking_report;
  }
}

// optional .bgs.protocol.report.v1.BottingReport botting_report = 16;
inline bool ReportType::has_botting_report() const {
  return type_case() == kBottingReport;
}
inline void ReportType::set_has_botting_report() {
  _oneof_case_[0] = kBottingReport;
}
inline void ReportType::clear_botting_report() {
  if (has_botting_report()) {
    delete type_.botting_report_;
    clear_has_type();
  }
}
inline const ::bgs::protocol::report::v1::BottingReport& ReportType::botting_report() const {
  return has_botting_report() ? *type_.botting_report_
                      : ::bgs::protocol::report::v1::BottingReport::default_instance();
}
inline ::bgs::protocol::report::v1::BottingReport* ReportType::mutable_botting_report() {
  if (!has_botting_report()) {
    clear_type();
    set_has_botting_report();
    type_.botting_report_ = new ::bgs::protocol::report::v1::BottingReport;
  }
  return type_.botting_report_;
}
inline ::bgs::protocol::report::v1::BottingReport* ReportType::release_botting_report() {
  if (has_botting_report()) {
    clear_has_type();
    ::bgs::protocol::report::v1::BottingReport* temp = type_.botting_report_;
    type_.botting_report_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void ReportType::set_allocated_botting_report(::bgs::protocol::report::v1::BottingReport* botting_report) {
  clear_type();
  if (botting_report) {
    set_has_botting_report();
    type_.botting_report_ = botting_report;
  }
}

inline bool ReportType::has_type() {
  return type_case() != TYPE_NOT_SET;
}
inline void ReportType::clear_has_type() {
  _oneof_case_[0] = TYPE_NOT_SET;
}
inline ReportType::TypeCase ReportType::type_case() const {
  return ReportType::TypeCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// CustomReport

// optional string type = 1;
inline bool CustomReport::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void CustomReport::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void CustomReport::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void CustomReport::clear_type() {
  if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    type_->clear();
  }
  clear_has_type();
}
inline const ::std::string& CustomReport::type() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.CustomReport.type)
  return *type_;
}
inline void CustomReport::set_type(const ::std::string& value) {
  set_has_type();
  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    type_ = new ::std::string;
  }
  type_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.CustomReport.type)
}
inline void CustomReport::set_type(const char* value) {
  set_has_type();
  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    type_ = new ::std::string;
  }
  type_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.report.v1.CustomReport.type)
}
inline void CustomReport::set_type(const char* value, size_t size) {
  set_has_type();
  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    type_ = new ::std::string;
  }
  type_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.report.v1.CustomReport.type)
}
inline ::std::string* CustomReport::mutable_type() {
  set_has_type();
  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    type_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.CustomReport.type)
  return type_;
}
inline ::std::string* CustomReport::release_type() {
  clear_has_type();
  if (type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = type_;
    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void CustomReport::set_allocated_type(::std::string* type) {
  if (type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete type_;
  }
  if (type) {
    set_has_type();
    type_ = type;
  } else {
    clear_has_type();
    type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.CustomReport.type)
}

// optional string program_id = 2 [deprecated = true];
inline bool CustomReport::has_program_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void CustomReport::set_has_program_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void CustomReport::clear_has_program_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void CustomReport::clear_program_id() {
  if (program_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    program_id_->clear();
  }
  clear_has_program_id();
}
inline const ::std::string& CustomReport::program_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.CustomReport.program_id)
  return *program_id_;
}
inline void CustomReport::set_program_id(const ::std::string& value) {
  set_has_program_id();
  if (program_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    program_id_ = new ::std::string;
  }
  program_id_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.CustomReport.program_id)
}
inline void CustomReport::set_program_id(const char* value) {
  set_has_program_id();
  if (program_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    program_id_ = new ::std::string;
  }
  program_id_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.report.v1.CustomReport.program_id)
}
inline void CustomReport::set_program_id(const char* value, size_t size) {
  set_has_program_id();
  if (program_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    program_id_ = new ::std::string;
  }
  program_id_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.report.v1.CustomReport.program_id)
}
inline ::std::string* CustomReport::mutable_program_id() {
  set_has_program_id();
  if (program_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    program_id_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.CustomReport.program_id)
  return program_id_;
}
inline ::std::string* CustomReport::release_program_id() {
  clear_has_program_id();
  if (program_id_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = program_id_;
    program_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void CustomReport::set_allocated_program_id(::std::string* program_id) {
  if (program_id_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete program_id_;
  }
  if (program_id) {
    set_has_program_id();
    program_id_ = program_id;
  } else {
    clear_has_program_id();
    program_id_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.CustomReport.program_id)
}

// repeated .bgs.protocol.Attribute attribute = 3;
inline int CustomReport::attribute_size() const {
  return attribute_.size();
}
inline void CustomReport::clear_attribute() {
  attribute_.Clear();
}
inline const ::bgs::protocol::Attribute& CustomReport::attribute(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.CustomReport.attribute)
  return attribute_.Get(index);
}
inline ::bgs::protocol::Attribute* CustomReport::mutable_attribute(int index) {
  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.CustomReport.attribute)
  return attribute_.Mutable(index);
}
inline ::bgs::protocol::Attribute* CustomReport::add_attribute() {
  // @@protoc_insertion_point(field_add:bgs.protocol.report.v1.CustomReport.attribute)
  return attribute_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
CustomReport::attribute() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.report.v1.CustomReport.attribute)
  return attribute_;
}
inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
CustomReport::mutable_attribute() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.report.v1.CustomReport.attribute)
  return &attribute_;
}

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

// SpamReport

// optional .bgs.protocol.account.v1.GameAccountHandle target = 1;
inline bool SpamReport::has_target() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SpamReport::set_has_target() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SpamReport::clear_has_target() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SpamReport::clear_target() {
  if (target_ != NULL) target_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
  clear_has_target();
}
inline const ::bgs::protocol::account::v1::GameAccountHandle& SpamReport::target() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.SpamReport.target)
  return target_ != NULL ? *target_ : *default_instance_->target_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* SpamReport::mutable_target() {
  set_has_target();
  if (target_ == NULL) target_ = new ::bgs::protocol::account::v1::GameAccountHandle;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.SpamReport.target)
  return target_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* SpamReport::release_target() {
  clear_has_target();
  ::bgs::protocol::account::v1::GameAccountHandle* temp = target_;
  target_ = NULL;
  return temp;
}
inline void SpamReport::set_allocated_target(::bgs::protocol::account::v1::GameAccountHandle* target) {
  delete target_;
  target_ = target;
  if (target) {
    set_has_target();
  } else {
    clear_has_target();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.SpamReport.target)
}

// optional .bgs.protocol.report.v1.SpamReport.SpamSource source = 2 [default = OTHER];
inline bool SpamReport::has_source() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SpamReport::set_has_source() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SpamReport::clear_has_source() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SpamReport::clear_source() {
  source_ = 1;
  clear_has_source();
}
inline ::bgs::protocol::report::v1::SpamReport_SpamSource SpamReport::source() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.SpamReport.source)
  return static_cast< ::bgs::protocol::report::v1::SpamReport_SpamSource >(source_);
}
inline void SpamReport::set_source(::bgs::protocol::report::v1::SpamReport_SpamSource value) {
  assert(::bgs::protocol::report::v1::SpamReport_SpamSource_IsValid(value));
  set_has_source();
  source_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.SpamReport.source)
}

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

// HarassmentReport

// optional .bgs.protocol.account.v1.GameAccountHandle target = 1;
inline bool HarassmentReport::has_target() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HarassmentReport::set_has_target() {
  _has_bits_[0] |= 0x00000001u;
}
inline void HarassmentReport::clear_has_target() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void HarassmentReport::clear_target() {
  if (target_ != NULL) target_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
  clear_has_target();
}
inline const ::bgs::protocol::account::v1::GameAccountHandle& HarassmentReport::target() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.HarassmentReport.target)
  return target_ != NULL ? *target_ : *default_instance_->target_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* HarassmentReport::mutable_target() {
  set_has_target();
  if (target_ == NULL) target_ = new ::bgs::protocol::account::v1::GameAccountHandle;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.HarassmentReport.target)
  return target_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* HarassmentReport::release_target() {
  clear_has_target();
  ::bgs::protocol::account::v1::GameAccountHandle* temp = target_;
  target_ = NULL;
  return temp;
}
inline void HarassmentReport::set_allocated_target(::bgs::protocol::account::v1::GameAccountHandle* target) {
  delete target_;
  target_ = target;
  if (target) {
    set_has_target();
  } else {
    clear_has_target();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.HarassmentReport.target)
}

// optional string text = 2;
inline bool HarassmentReport::has_text() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void HarassmentReport::set_has_text() {
  _has_bits_[0] |= 0x00000002u;
}
inline void HarassmentReport::clear_has_text() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void HarassmentReport::clear_text() {
  if (text_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    text_->clear();
  }
  clear_has_text();
}
inline const ::std::string& HarassmentReport::text() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.HarassmentReport.text)
  return *text_;
}
inline void HarassmentReport::set_text(const ::std::string& value) {
  set_has_text();
  if (text_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    text_ = new ::std::string;
  }
  text_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.HarassmentReport.text)
}
inline void HarassmentReport::set_text(const char* value) {
  set_has_text();
  if (text_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    text_ = new ::std::string;
  }
  text_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.report.v1.HarassmentReport.text)
}
inline void HarassmentReport::set_text(const char* value, size_t size) {
  set_has_text();
  if (text_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    text_ = new ::std::string;
  }
  text_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.report.v1.HarassmentReport.text)
}
inline ::std::string* HarassmentReport::mutable_text() {
  set_has_text();
  if (text_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    text_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.HarassmentReport.text)
  return text_;
}
inline ::std::string* HarassmentReport::release_text() {
  clear_has_text();
  if (text_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = text_;
    text_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void HarassmentReport::set_allocated_text(::std::string* text) {
  if (text_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete text_;
  }
  if (text) {
    set_has_text();
    text_ = text;
  } else {
    clear_has_text();
    text_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.HarassmentReport.text)
}

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

// RealLifeThreatReport

// optional .bgs.protocol.account.v1.GameAccountHandle target = 1;
inline bool RealLifeThreatReport::has_target() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RealLifeThreatReport::set_has_target() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RealLifeThreatReport::clear_has_target() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RealLifeThreatReport::clear_target() {
  if (target_ != NULL) target_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
  clear_has_target();
}
inline const ::bgs::protocol::account::v1::GameAccountHandle& RealLifeThreatReport::target() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.RealLifeThreatReport.target)
  return target_ != NULL ? *target_ : *default_instance_->target_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* RealLifeThreatReport::mutable_target() {
  set_has_target();
  if (target_ == NULL) target_ = new ::bgs::protocol::account::v1::GameAccountHandle;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.RealLifeThreatReport.target)
  return target_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* RealLifeThreatReport::release_target() {
  clear_has_target();
  ::bgs::protocol::account::v1::GameAccountHandle* temp = target_;
  target_ = NULL;
  return temp;
}
inline void RealLifeThreatReport::set_allocated_target(::bgs::protocol::account::v1::GameAccountHandle* target) {
  delete target_;
  target_ = target;
  if (target) {
    set_has_target();
  } else {
    clear_has_target();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.RealLifeThreatReport.target)
}

// optional string text = 2;
inline bool RealLifeThreatReport::has_text() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RealLifeThreatReport::set_has_text() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RealLifeThreatReport::clear_has_text() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RealLifeThreatReport::clear_text() {
  if (text_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    text_->clear();
  }
  clear_has_text();
}
inline const ::std::string& RealLifeThreatReport::text() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.RealLifeThreatReport.text)
  return *text_;
}
inline void RealLifeThreatReport::set_text(const ::std::string& value) {
  set_has_text();
  if (text_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    text_ = new ::std::string;
  }
  text_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.RealLifeThreatReport.text)
}
inline void RealLifeThreatReport::set_text(const char* value) {
  set_has_text();
  if (text_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    text_ = new ::std::string;
  }
  text_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.report.v1.RealLifeThreatReport.text)
}
inline void RealLifeThreatReport::set_text(const char* value, size_t size) {
  set_has_text();
  if (text_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    text_ = new ::std::string;
  }
  text_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.report.v1.RealLifeThreatReport.text)
}
inline ::std::string* RealLifeThreatReport::mutable_text() {
  set_has_text();
  if (text_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    text_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.RealLifeThreatReport.text)
  return text_;
}
inline ::std::string* RealLifeThreatReport::release_text() {
  clear_has_text();
  if (text_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = text_;
    text_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void RealLifeThreatReport::set_allocated_text(::std::string* text) {
  if (text_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete text_;
  }
  if (text) {
    set_has_text();
    text_ = text;
  } else {
    clear_has_text();
    text_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.RealLifeThreatReport.text)
}

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

// InappropriateBattleTagReport

// optional .bgs.protocol.account.v1.GameAccountHandle target = 1;
inline bool InappropriateBattleTagReport::has_target() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void InappropriateBattleTagReport::set_has_target() {
  _has_bits_[0] |= 0x00000001u;
}
inline void InappropriateBattleTagReport::clear_has_target() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void InappropriateBattleTagReport::clear_target() {
  if (target_ != NULL) target_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
  clear_has_target();
}
inline const ::bgs::protocol::account::v1::GameAccountHandle& InappropriateBattleTagReport::target() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.InappropriateBattleTagReport.target)
  return target_ != NULL ? *target_ : *default_instance_->target_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* InappropriateBattleTagReport::mutable_target() {
  set_has_target();
  if (target_ == NULL) target_ = new ::bgs::protocol::account::v1::GameAccountHandle;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.InappropriateBattleTagReport.target)
  return target_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* InappropriateBattleTagReport::release_target() {
  clear_has_target();
  ::bgs::protocol::account::v1::GameAccountHandle* temp = target_;
  target_ = NULL;
  return temp;
}
inline void InappropriateBattleTagReport::set_allocated_target(::bgs::protocol::account::v1::GameAccountHandle* target) {
  delete target_;
  target_ = target;
  if (target) {
    set_has_target();
  } else {
    clear_has_target();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.InappropriateBattleTagReport.target)
}

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

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

// HackingReport

// optional .bgs.protocol.account.v1.GameAccountHandle target = 1;
inline bool HackingReport::has_target() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HackingReport::set_has_target() {
  _has_bits_[0] |= 0x00000001u;
}
inline void HackingReport::clear_has_target() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void HackingReport::clear_target() {
  if (target_ != NULL) target_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
  clear_has_target();
}
inline const ::bgs::protocol::account::v1::GameAccountHandle& HackingReport::target() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.HackingReport.target)
  return target_ != NULL ? *target_ : *default_instance_->target_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* HackingReport::mutable_target() {
  set_has_target();
  if (target_ == NULL) target_ = new ::bgs::protocol::account::v1::GameAccountHandle;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.HackingReport.target)
  return target_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* HackingReport::release_target() {
  clear_has_target();
  ::bgs::protocol::account::v1::GameAccountHandle* temp = target_;
  target_ = NULL;
  return temp;
}
inline void HackingReport::set_allocated_target(::bgs::protocol::account::v1::GameAccountHandle* target) {
  delete target_;
  target_ = target;
  if (target) {
    set_has_target();
  } else {
    clear_has_target();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.HackingReport.target)
}

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

// BottingReport

// optional .bgs.protocol.account.v1.GameAccountHandle target = 1;
inline bool BottingReport::has_target() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BottingReport::set_has_target() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BottingReport::clear_has_target() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BottingReport::clear_target() {
  if (target_ != NULL) target_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
  clear_has_target();
}
inline const ::bgs::protocol::account::v1::GameAccountHandle& BottingReport::target() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.BottingReport.target)
  return target_ != NULL ? *target_ : *default_instance_->target_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* BottingReport::mutable_target() {
  set_has_target();
  if (target_ == NULL) target_ = new ::bgs::protocol::account::v1::GameAccountHandle;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.BottingReport.target)
  return target_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* BottingReport::release_target() {
  clear_has_target();
  ::bgs::protocol::account::v1::GameAccountHandle* temp = target_;
  target_ = NULL;
  return temp;
}
inline void BottingReport::set_allocated_target(::bgs::protocol::account::v1::GameAccountHandle* target) {
  delete target_;
  target_ = target;
  if (target) {
    set_has_target();
  } else {
    clear_has_target();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.BottingReport.target)
}

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

// Report

// required string report_type = 1;
inline bool Report::has_report_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Report::set_has_report_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Report::clear_has_report_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Report::clear_report_type() {
  if (report_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    report_type_->clear();
  }
  clear_has_report_type();
}
inline const ::std::string& Report::report_type() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.report_type)
  return *report_type_;
}
inline void Report::set_report_type(const ::std::string& value) {
  set_has_report_type();
  if (report_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    report_type_ = new ::std::string;
  }
  report_type_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.Report.report_type)
}
inline void Report::set_report_type(const char* value) {
  set_has_report_type();
  if (report_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    report_type_ = new ::std::string;
  }
  report_type_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.report.v1.Report.report_type)
}
inline void Report::set_report_type(const char* value, size_t size) {
  set_has_report_type();
  if (report_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    report_type_ = new ::std::string;
  }
  report_type_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.report.v1.Report.report_type)
}
inline ::std::string* Report::mutable_report_type() {
  set_has_report_type();
  if (report_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    report_type_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.Report.report_type)
  return report_type_;
}
inline ::std::string* Report::release_report_type() {
  clear_has_report_type();
  if (report_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = report_type_;
    report_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void Report::set_allocated_report_type(::std::string* report_type) {
  if (report_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete report_type_;
  }
  if (report_type) {
    set_has_report_type();
    report_type_ = report_type;
  } else {
    clear_has_report_type();
    report_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.Report.report_type)
}

// repeated .bgs.protocol.Attribute attribute = 2;
inline int Report::attribute_size() const {
  return attribute_.size();
}
inline void Report::clear_attribute() {
  attribute_.Clear();
}
inline const ::bgs::protocol::Attribute& Report::attribute(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.attribute)
  return attribute_.Get(index);
}
inline ::bgs::protocol::Attribute* Report::mutable_attribute(int index) {
  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.Report.attribute)
  return attribute_.Mutable(index);
}
inline ::bgs::protocol::Attribute* Report::add_attribute() {
  // @@protoc_insertion_point(field_add:bgs.protocol.report.v1.Report.attribute)
  return attribute_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >&
Report::attribute() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.report.v1.Report.attribute)
  return attribute_;
}
inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute >*
Report::mutable_attribute() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.report.v1.Report.attribute)
  return &attribute_;
}

// optional int32 report_qos = 3 [default = 0];
inline bool Report::has_report_qos() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Report::set_has_report_qos() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Report::clear_has_report_qos() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Report::clear_report_qos() {
  report_qos_ = 0;
  clear_has_report_qos();
}
inline ::google::protobuf::int32 Report::report_qos() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.report_qos)
  return report_qos_;
}
inline void Report::set_report_qos(::google::protobuf::int32 value) {
  set_has_report_qos();
  report_qos_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.Report.report_qos)
}

// optional .bgs.protocol.EntityId reporting_account = 4;
inline bool Report::has_reporting_account() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Report::set_has_reporting_account() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Report::clear_has_reporting_account() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Report::clear_reporting_account() {
  if (reporting_account_ != NULL) reporting_account_->::bgs::protocol::EntityId::Clear();
  clear_has_reporting_account();
}
inline const ::bgs::protocol::EntityId& Report::reporting_account() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.reporting_account)
  return reporting_account_ != NULL ? *reporting_account_ : *default_instance_->reporting_account_;
}
inline ::bgs::protocol::EntityId* Report::mutable_reporting_account() {
  set_has_reporting_account();
  if (reporting_account_ == NULL) reporting_account_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.Report.reporting_account)
  return reporting_account_;
}
inline ::bgs::protocol::EntityId* Report::release_reporting_account() {
  clear_has_reporting_account();
  ::bgs::protocol::EntityId* temp = reporting_account_;
  reporting_account_ = NULL;
  return temp;
}
inline void Report::set_allocated_reporting_account(::bgs::protocol::EntityId* reporting_account) {
  delete reporting_account_;
  reporting_account_ = reporting_account;
  if (reporting_account) {
    set_has_reporting_account();
  } else {
    clear_has_reporting_account();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.Report.reporting_account)
}

// optional .bgs.protocol.EntityId reporting_game_account = 5;
inline bool Report::has_reporting_game_account() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Report::set_has_reporting_game_account() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Report::clear_has_reporting_game_account() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void Report::clear_reporting_game_account() {
  if (reporting_game_account_ != NULL) reporting_game_account_->::bgs::protocol::EntityId::Clear();
  clear_has_reporting_game_account();
}
inline const ::bgs::protocol::EntityId& Report::reporting_game_account() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.reporting_game_account)
  return reporting_game_account_ != NULL ? *reporting_game_account_ : *default_instance_->reporting_game_account_;
}
inline ::bgs::protocol::EntityId* Report::mutable_reporting_game_account() {
  set_has_reporting_game_account();
  if (reporting_game_account_ == NULL) reporting_game_account_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.report.v1.Report.reporting_game_account)
  return reporting_game_account_;
}
inline ::bgs::protocol::EntityId* Report::release_reporting_game_account() {
  clear_has_reporting_game_account();
  ::bgs::protocol::EntityId* temp = reporting_game_account_;
  reporting_game_account_ = NULL;
  return temp;
}
inline void Report::set_allocated_reporting_game_account(::bgs::protocol::EntityId* reporting_game_account) {
  delete reporting_game_account_;
  reporting_game_account_ = reporting_game_account;
  if (reporting_game_account) {
    set_has_reporting_game_account();
  } else {
    clear_has_reporting_game_account();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.report.v1.Report.reporting_game_account)
}

// optional fixed64 report_timestamp = 6;
inline bool Report::has_report_timestamp() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Report::set_has_report_timestamp() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Report::clear_has_report_timestamp() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Report::clear_report_timestamp() {
  report_timestamp_ = GOOGLE_ULONGLONG(0);
  clear_has_report_timestamp();
}
inline ::google::protobuf::uint64 Report::report_timestamp() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.report.v1.Report.report_timestamp)
  return report_timestamp_;
}
inline void Report::set_report_timestamp(::google::protobuf::uint64 value) {
  set_has_report_timestamp();
  report_timestamp_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.report.v1.Report.report_timestamp)
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace v1
}  // namespace report
}  // namespace protocol
}  // namespace bgs

#ifndef SWIG
namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::bgs::protocol::report::v1::SpamReport_SpamSource> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::report::v1::SpamReport_SpamSource>() {
  return ::bgs::protocol::report::v1::SpamReport_SpamSource_descriptor();
}

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

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_report_5ftypes_2eproto__INCLUDED
