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

#ifndef PROTOBUF_channel_5ftypes_2eproto__INCLUDED
#define PROTOBUF_channel_5ftypes_2eproto__INCLUDED

#include <string>

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

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

#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "api/client/v1/channel_id.pb.h"  // IWYU pragma: export
#include "attribute_types.pb.h"
#include "entity_types.pb.h"
#include "account_types.pb.h"
#include "invitation_types.pb.h"
#include "rpc_types.pb.h"
#include "Define.h" // for TC_PROTO_API
// @@protoc_insertion_point(includes)

namespace bgs {
namespace protocol {
namespace channel {
namespace v1 {

// Internal implementation detail -- do not call these.
void TC_PROTO_API protobuf_AddDesc_channel_5ftypes_2eproto();
void protobuf_AssignDesc_channel_5ftypes_2eproto();
void protobuf_ShutdownFile_channel_5ftypes_2eproto();

class Message;
class ListChannelsOptions;
class ChannelDescription;
class ChannelInfo;
class ChannelState;
class MemberAccountInfo;
class MemberState;
class Member;
class SubscriberId;

enum ChannelState_PrivacyLevel {
  ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN = 1,
  ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN_INVITATION_AND_FRIEND = 2,
  ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN_INVITATION = 3,
  ChannelState_PrivacyLevel_PRIVACY_LEVEL_CLOSED = 4
};
TC_PROTO_API bool ChannelState_PrivacyLevel_IsValid(int value);
const ChannelState_PrivacyLevel ChannelState_PrivacyLevel_PrivacyLevel_MIN = ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN;
const ChannelState_PrivacyLevel ChannelState_PrivacyLevel_PrivacyLevel_MAX = ChannelState_PrivacyLevel_PRIVACY_LEVEL_CLOSED;
const int ChannelState_PrivacyLevel_PrivacyLevel_ARRAYSIZE = ChannelState_PrivacyLevel_PrivacyLevel_MAX + 1;

TC_PROTO_API const ::google::protobuf::EnumDescriptor* ChannelState_PrivacyLevel_descriptor();
inline const ::std::string& ChannelState_PrivacyLevel_Name(ChannelState_PrivacyLevel value) {
  return ::google::protobuf::internal::NameOfEnum(
    ChannelState_PrivacyLevel_descriptor(), value);
}
inline bool ChannelState_PrivacyLevel_Parse(
    const ::std::string& name, ChannelState_PrivacyLevel* value) {
  return ::google::protobuf::internal::ParseNamedEnum<ChannelState_PrivacyLevel>(
    ChannelState_PrivacyLevel_descriptor(), name, value);
}
// ===================================================================

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

  Message(const Message& from);

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

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

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

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

  void Swap(Message* other);

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

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

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

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

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

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

  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(Message)
  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.Message)
 private:

  ::google::protobuf::internal::ExtensionSet _extensions_;

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
  friend void TC_PROTO_API protobuf_AddDesc_channel_5ftypes_2eproto();
  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();

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

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

  ListChannelsOptions(const ListChannelsOptions& from);

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

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

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

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

  void Swap(ListChannelsOptions* other);

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

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

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

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

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

  // optional uint32 start_index = 1 [default = 0];
  inline bool has_start_index() const;
  inline void clear_start_index();
  static const int kStartIndexFieldNumber = 1;
  inline ::google::protobuf::uint32 start_index() const;
  inline void set_start_index(::google::protobuf::uint32 value);

  // optional uint32 max_results = 2 [default = 16];
  inline bool has_max_results() const;
  inline void clear_max_results();
  static const int kMaxResultsFieldNumber = 2;
  inline ::google::protobuf::uint32 max_results() const;
  inline void set_max_results(::google::protobuf::uint32 value);

  // optional string name = 3;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 3;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();
  inline void set_allocated_name(::std::string* name);

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

  // optional fixed32 locale = 5;
  inline bool has_locale() const;
  inline void clear_locale();
  static const int kLocaleFieldNumber = 5;
  inline ::google::protobuf::uint32 locale() const;
  inline void set_locale(::google::protobuf::uint32 value);

  // optional uint32 capacity_full = 6;
  inline bool has_capacity_full() const;
  inline void clear_capacity_full();
  static const int kCapacityFullFieldNumber = 6;
  inline ::google::protobuf::uint32 capacity_full() const;
  inline void set_capacity_full(::google::protobuf::uint32 value);

  // required .bgs.protocol.AttributeFilter attribute_filter = 7;
  inline bool has_attribute_filter() const;
  inline void clear_attribute_filter();
  static const int kAttributeFilterFieldNumber = 7;
  inline const ::bgs::protocol::AttributeFilter& attribute_filter() const;
  inline ::bgs::protocol::AttributeFilter* mutable_attribute_filter();
  inline ::bgs::protocol::AttributeFilter* release_attribute_filter();
  inline void set_allocated_attribute_filter(::bgs::protocol::AttributeFilter* attribute_filter);

  // optional string channel_type = 8;
  inline bool has_channel_type() const;
  inline void clear_channel_type();
  static const int kChannelTypeFieldNumber = 8;
  inline const ::std::string& channel_type() const;
  inline void set_channel_type(const ::std::string& value);
  inline void set_channel_type(const char* value);
  inline void set_channel_type(const char* value, size_t size);
  inline ::std::string* mutable_channel_type();
  inline ::std::string* release_channel_type();
  inline void set_allocated_channel_type(::std::string* channel_type);

  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.ListChannelsOptions)
 private:
  inline void set_has_start_index();
  inline void clear_has_start_index();
  inline void set_has_max_results();
  inline void clear_has_max_results();
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_program();
  inline void clear_has_program();
  inline void set_has_locale();
  inline void clear_has_locale();
  inline void set_has_capacity_full();
  inline void clear_has_capacity_full();
  inline void set_has_attribute_filter();
  inline void clear_has_attribute_filter();
  inline void set_has_channel_type();
  inline void clear_has_channel_type();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint32 start_index_;
  ::google::protobuf::uint32 max_results_;
  ::std::string* name_;
  ::google::protobuf::uint32 program_;
  ::google::protobuf::uint32 locale_;
  ::bgs::protocol::AttributeFilter* attribute_filter_;
  ::std::string* channel_type_;
  ::google::protobuf::uint32 capacity_full_;
  friend void TC_PROTO_API protobuf_AddDesc_channel_5ftypes_2eproto();
  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();

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

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

  ChannelDescription(const ChannelDescription& from);

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

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

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

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

  void Swap(ChannelDescription* other);

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

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

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

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

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

  // required .bgs.protocol.EntityId channel_id = 1;
  inline bool has_channel_id() const;
  inline void clear_channel_id();
  static const int kChannelIdFieldNumber = 1;
  inline const ::bgs::protocol::EntityId& channel_id() const;
  inline ::bgs::protocol::EntityId* mutable_channel_id();
  inline ::bgs::protocol::EntityId* release_channel_id();
  inline void set_allocated_channel_id(::bgs::protocol::EntityId* channel_id);

  // optional uint32 current_members = 2;
  inline bool has_current_members() const;
  inline void clear_current_members();
  static const int kCurrentMembersFieldNumber = 2;
  inline ::google::protobuf::uint32 current_members() const;
  inline void set_current_members(::google::protobuf::uint32 value);

  // optional .bgs.protocol.channel.v1.ChannelState state = 3;
  inline bool has_state() const;
  inline void clear_state();
  static const int kStateFieldNumber = 3;
  inline const ::bgs::protocol::channel::v1::ChannelState& state() const;
  inline ::bgs::protocol::channel::v1::ChannelState* mutable_state();
  inline ::bgs::protocol::channel::v1::ChannelState* release_state();
  inline void set_allocated_state(::bgs::protocol::channel::v1::ChannelState* state);

  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.ChannelDescription)
 private:
  inline void set_has_channel_id();
  inline void clear_has_channel_id();
  inline void set_has_current_members();
  inline void clear_has_current_members();
  inline void set_has_state();
  inline void clear_has_state();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::EntityId* channel_id_;
  ::bgs::protocol::channel::v1::ChannelState* state_;
  ::google::protobuf::uint32 current_members_;
  friend void TC_PROTO_API protobuf_AddDesc_channel_5ftypes_2eproto();
  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();

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

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

  ChannelInfo(const ChannelInfo& from);

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

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

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

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

  void Swap(ChannelInfo* other);

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

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

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

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

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

  // required .bgs.protocol.channel.v1.ChannelDescription description = 1;
  inline bool has_description() const;
  inline void clear_description();
  static const int kDescriptionFieldNumber = 1;
  inline const ::bgs::protocol::channel::v1::ChannelDescription& description() const;
  inline ::bgs::protocol::channel::v1::ChannelDescription* mutable_description();
  inline ::bgs::protocol::channel::v1::ChannelDescription* release_description();
  inline void set_allocated_description(::bgs::protocol::channel::v1::ChannelDescription* description);

  // repeated .bgs.protocol.channel.v1.Member member = 2;
  inline int member_size() const;
  inline void clear_member();
  static const int kMemberFieldNumber = 2;
  inline const ::bgs::protocol::channel::v1::Member& member(int index) const;
  inline ::bgs::protocol::channel::v1::Member* mutable_member(int index);
  inline ::bgs::protocol::channel::v1::Member* add_member();
  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >&
      member() const;
  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >*
      mutable_member();

  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.ChannelInfo)
 private:
  inline void set_has_description();
  inline void clear_has_description();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::channel::v1::ChannelDescription* description_;
  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member > member_;
  friend void TC_PROTO_API protobuf_AddDesc_channel_5ftypes_2eproto();
  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();

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

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

  ChannelState(const ChannelState& from);

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

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

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

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

  void Swap(ChannelState* other);

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

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

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

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

  typedef ChannelState_PrivacyLevel PrivacyLevel;
  static const PrivacyLevel PRIVACY_LEVEL_OPEN = ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN;
  static const PrivacyLevel PRIVACY_LEVEL_OPEN_INVITATION_AND_FRIEND = ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN_INVITATION_AND_FRIEND;
  static const PrivacyLevel PRIVACY_LEVEL_OPEN_INVITATION = ChannelState_PrivacyLevel_PRIVACY_LEVEL_OPEN_INVITATION;
  static const PrivacyLevel PRIVACY_LEVEL_CLOSED = ChannelState_PrivacyLevel_PRIVACY_LEVEL_CLOSED;
  static inline bool PrivacyLevel_IsValid(int value) {
    return ChannelState_PrivacyLevel_IsValid(value);
  }
  static const PrivacyLevel PrivacyLevel_MIN =
    ChannelState_PrivacyLevel_PrivacyLevel_MIN;
  static const PrivacyLevel PrivacyLevel_MAX =
    ChannelState_PrivacyLevel_PrivacyLevel_MAX;
  static const int PrivacyLevel_ARRAYSIZE =
    ChannelState_PrivacyLevel_PrivacyLevel_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  PrivacyLevel_descriptor() {
    return ChannelState_PrivacyLevel_descriptor();
  }
  static inline const ::std::string& PrivacyLevel_Name(PrivacyLevel value) {
    return ChannelState_PrivacyLevel_Name(value);
  }
  static inline bool PrivacyLevel_Parse(const ::std::string& name,
      PrivacyLevel* value) {
    return ChannelState_PrivacyLevel_Parse(name, value);
  }

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

  // optional uint32 max_members = 1;
  inline bool has_max_members() const;
  inline void clear_max_members();
  static const int kMaxMembersFieldNumber = 1;
  inline ::google::protobuf::uint32 max_members() const;
  inline void set_max_members(::google::protobuf::uint32 value);

  // optional uint32 min_members = 2;
  inline bool has_min_members() const;
  inline void clear_min_members();
  static const int kMinMembersFieldNumber = 2;
  inline ::google::protobuf::uint32 min_members() const;
  inline void set_min_members(::google::protobuf::uint32 value);

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

  // repeated .bgs.protocol.Invitation invitation = 4;
  inline int invitation_size() const;
  inline void clear_invitation();
  static const int kInvitationFieldNumber = 4;
  inline const ::bgs::protocol::Invitation& invitation(int index) const;
  inline ::bgs::protocol::Invitation* mutable_invitation(int index);
  inline ::bgs::protocol::Invitation* add_invitation();
  inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >&
      invitation() const;
  inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >*
      mutable_invitation();

  // optional uint32 reason = 6;
  inline bool has_reason() const;
  inline void clear_reason();
  static const int kReasonFieldNumber = 6;
  inline ::google::protobuf::uint32 reason() const;
  inline void set_reason(::google::protobuf::uint32 value);

  // optional .bgs.protocol.channel.v1.ChannelState.PrivacyLevel privacy_level = 7 [default = PRIVACY_LEVEL_OPEN];
  inline bool has_privacy_level() const;
  inline void clear_privacy_level();
  static const int kPrivacyLevelFieldNumber = 7;
  inline ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel privacy_level() const;
  inline void set_privacy_level(::bgs::protocol::channel::v1::ChannelState_PrivacyLevel value);

  // optional string name = 8;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 8;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  inline ::std::string* release_name();
  inline void set_allocated_name(::std::string* name);

  // optional string channel_type = 10 [default = "default"];
  inline bool has_channel_type() const;
  inline void clear_channel_type();
  static const int kChannelTypeFieldNumber = 10;
  inline const ::std::string& channel_type() const;
  inline void set_channel_type(const ::std::string& value);
  inline void set_channel_type(const char* value);
  inline void set_channel_type(const char* value, size_t size);
  inline ::std::string* mutable_channel_type();
  inline ::std::string* release_channel_type();
  inline void set_allocated_channel_type(::std::string* channel_type);

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

  // optional bool subscribe_to_presence = 13 [default = true];
  inline bool has_subscribe_to_presence() const;
  inline void clear_subscribe_to_presence();
  static const int kSubscribeToPresenceFieldNumber = 13;
  inline bool subscribe_to_presence() const;
  inline void set_subscribe_to_presence(bool value);

  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ChannelState)
  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.ChannelState)
 private:
  inline void set_has_max_members();
  inline void clear_has_max_members();
  inline void set_has_min_members();
  inline void clear_has_min_members();
  inline void set_has_reason();
  inline void clear_has_reason();
  inline void set_has_privacy_level();
  inline void clear_has_privacy_level();
  inline void set_has_name();
  inline void clear_has_name();
  inline void set_has_channel_type();
  inline void clear_has_channel_type();
  inline void set_has_program();
  inline void clear_has_program();
  inline void set_has_subscribe_to_presence();
  inline void clear_has_subscribe_to_presence();

  ::google::protobuf::internal::ExtensionSet _extensions_;

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::uint32 max_members_;
  ::google::protobuf::uint32 min_members_;
  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation > invitation_;
  ::google::protobuf::uint32 reason_;
  int privacy_level_;
  ::std::string* name_;
  static ::std::string* _default_channel_type_;
  ::std::string* channel_type_;
  ::google::protobuf::uint32 program_;
  bool subscribe_to_presence_;
  friend void TC_PROTO_API protobuf_AddDesc_channel_5ftypes_2eproto();
  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();

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

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

  MemberAccountInfo(const MemberAccountInfo& from);

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

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

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

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

  void Swap(MemberAccountInfo* other);

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

  MemberAccountInfo* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const MemberAccountInfo& from);
  void MergeFrom(const MemberAccountInfo& 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 battle_tag = 3;
  inline bool has_battle_tag() const;
  inline void clear_battle_tag();
  static const int kBattleTagFieldNumber = 3;
  inline const ::std::string& battle_tag() const;
  inline void set_battle_tag(const ::std::string& value);
  inline void set_battle_tag(const char* value);
  inline void set_battle_tag(const char* value, size_t size);
  inline ::std::string* mutable_battle_tag();
  inline ::std::string* release_battle_tag();
  inline void set_allocated_battle_tag(::std::string* battle_tag);

  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.MemberAccountInfo)
 private:
  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_;
  ::std::string* battle_tag_;
  friend void TC_PROTO_API protobuf_AddDesc_channel_5ftypes_2eproto();
  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();

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

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

  MemberState(const MemberState& from);

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

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

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

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

  void Swap(MemberState* other);

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

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

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

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

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

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

  // repeated uint32 role = 2 [packed = true];
  inline int role_size() const;
  inline void clear_role();
  static const int kRoleFieldNumber = 2;
  inline ::google::protobuf::uint32 role(int index) const;
  inline void set_role(int index, ::google::protobuf::uint32 value);
  inline void add_role(::google::protobuf::uint32 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
      role() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
      mutable_role();

  // optional uint64 privileges = 3 [default = 0];
  inline bool has_privileges() const;
  inline void clear_privileges();
  static const int kPrivilegesFieldNumber = 3;
  inline ::google::protobuf::uint64 privileges() const;
  inline void set_privileges(::google::protobuf::uint64 value);

  // optional .bgs.protocol.channel.v1.MemberAccountInfo info = 4;
  inline bool has_info() const;
  inline void clear_info();
  static const int kInfoFieldNumber = 4;
  inline const ::bgs::protocol::channel::v1::MemberAccountInfo& info() const;
  inline ::bgs::protocol::channel::v1::MemberAccountInfo* mutable_info();
  inline ::bgs::protocol::channel::v1::MemberAccountInfo* release_info();
  inline void set_allocated_info(::bgs::protocol::channel::v1::MemberAccountInfo* info);

  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.MemberState)
 private:
  inline void set_has_privileges();
  inline void clear_has_privileges();
  inline void set_has_info();
  inline void clear_has_info();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Attribute > attribute_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > role_;
  mutable int _role_cached_byte_size_;
  ::google::protobuf::uint64 privileges_;
  ::bgs::protocol::channel::v1::MemberAccountInfo* info_;
  friend void TC_PROTO_API protobuf_AddDesc_channel_5ftypes_2eproto();
  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();

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

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

  Member(const Member& from);

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

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

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

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

  void Swap(Member* other);

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

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

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

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

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

  // required .bgs.protocol.Identity identity = 1;
  inline bool has_identity() const;
  inline void clear_identity();
  static const int kIdentityFieldNumber = 1;
  inline const ::bgs::protocol::Identity& identity() const;
  inline ::bgs::protocol::Identity* mutable_identity();
  inline ::bgs::protocol::Identity* release_identity();
  inline void set_allocated_identity(::bgs::protocol::Identity* identity);

  // required .bgs.protocol.channel.v1.MemberState state = 2;
  inline bool has_state() const;
  inline void clear_state();
  static const int kStateFieldNumber = 2;
  inline const ::bgs::protocol::channel::v1::MemberState& state() const;
  inline ::bgs::protocol::channel::v1::MemberState* mutable_state();
  inline ::bgs::protocol::channel::v1::MemberState* release_state();
  inline void set_allocated_state(::bgs::protocol::channel::v1::MemberState* state);

  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.Member)
 private:
  inline void set_has_identity();
  inline void clear_has_identity();
  inline void set_has_state();
  inline void clear_has_state();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::Identity* identity_;
  ::bgs::protocol::channel::v1::MemberState* state_;
  friend void TC_PROTO_API protobuf_AddDesc_channel_5ftypes_2eproto();
  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();

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

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

  SubscriberId(const SubscriberId& from);

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

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

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

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

  void Swap(SubscriberId* other);

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

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

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

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

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

  // optional .bgs.protocol.account.v1.AccountId account = 1 [deprecated = true];
  inline bool has_account() const PROTOBUF_DEPRECATED;
  inline void clear_account() PROTOBUF_DEPRECATED;
  static const int kAccountFieldNumber = 1;
  inline const ::bgs::protocol::account::v1::AccountId& account() const PROTOBUF_DEPRECATED;
  inline ::bgs::protocol::account::v1::AccountId* mutable_account() PROTOBUF_DEPRECATED;
  inline ::bgs::protocol::account::v1::AccountId* release_account() PROTOBUF_DEPRECATED;
  inline void set_allocated_account(::bgs::protocol::account::v1::AccountId* account) PROTOBUF_DEPRECATED;

  // optional .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
  inline bool has_game_account() const;
  inline void clear_game_account();
  static const int kGameAccountFieldNumber = 2;
  inline const ::bgs::protocol::account::v1::GameAccountHandle& game_account() const;
  inline ::bgs::protocol::account::v1::GameAccountHandle* mutable_game_account();
  inline ::bgs::protocol::account::v1::GameAccountHandle* release_game_account();
  inline void set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account);

  // optional .bgs.protocol.ProcessId process = 3;
  inline bool has_process() const;
  inline void clear_process();
  static const int kProcessFieldNumber = 3;
  inline const ::bgs::protocol::ProcessId& process() const;
  inline ::bgs::protocol::ProcessId* mutable_process();
  inline ::bgs::protocol::ProcessId* release_process();
  inline void set_allocated_process(::bgs::protocol::ProcessId* process);

  // @@protoc_insertion_point(class_scope:bgs.protocol.channel.v1.SubscriberId)
 private:
  inline void set_has_account();
  inline void clear_has_account();
  inline void set_has_game_account();
  inline void clear_has_game_account();
  inline void set_has_process();
  inline void clear_has_process();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::account::v1::AccountId* account_;
  ::bgs::protocol::account::v1::GameAccountHandle* game_account_;
  ::bgs::protocol::ProcessId* process_;
  friend void TC_PROTO_API protobuf_AddDesc_channel_5ftypes_2eproto();
  friend void protobuf_AssignDesc_channel_5ftypes_2eproto();
  friend void protobuf_ShutdownFile_channel_5ftypes_2eproto();

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


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


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

// Message

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

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

// ListChannelsOptions

// optional uint32 start_index = 1 [default = 0];
inline bool ListChannelsOptions::has_start_index() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ListChannelsOptions::set_has_start_index() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ListChannelsOptions::clear_has_start_index() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ListChannelsOptions::clear_start_index() {
  start_index_ = 0u;
  clear_has_start_index();
}
inline ::google::protobuf::uint32 ListChannelsOptions::start_index() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.start_index)
  return start_index_;
}
inline void ListChannelsOptions::set_start_index(::google::protobuf::uint32 value) {
  set_has_start_index();
  start_index_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.start_index)
}

// optional uint32 max_results = 2 [default = 16];
inline bool ListChannelsOptions::has_max_results() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ListChannelsOptions::set_has_max_results() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ListChannelsOptions::clear_has_max_results() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ListChannelsOptions::clear_max_results() {
  max_results_ = 16u;
  clear_has_max_results();
}
inline ::google::protobuf::uint32 ListChannelsOptions::max_results() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.max_results)
  return max_results_;
}
inline void ListChannelsOptions::set_max_results(::google::protobuf::uint32 value) {
  set_has_max_results();
  max_results_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.max_results)
}

// optional string name = 3;
inline bool ListChannelsOptions::has_name() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ListChannelsOptions::set_has_name() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ListChannelsOptions::clear_has_name() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ListChannelsOptions::clear_name() {
  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& ListChannelsOptions::name() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.name)
  return *name_;
}
inline void ListChannelsOptions::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    name_ = new ::std::string;
  }
  name_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.name)
}
inline void ListChannelsOptions::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    name_ = new ::std::string;
  }
  name_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.ListChannelsOptions.name)
}
inline void ListChannelsOptions::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.ListChannelsOptions.name)
}
inline ::std::string* ListChannelsOptions::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    name_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ListChannelsOptions.name)
  return name_;
}
inline ::std::string* ListChannelsOptions::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void ListChannelsOptions::set_allocated_name(::std::string* name) {
  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete name_;
  }
  if (name) {
    set_has_name();
    name_ = name;
  } else {
    clear_has_name();
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ListChannelsOptions.name)
}

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

// optional fixed32 locale = 5;
inline bool ListChannelsOptions::has_locale() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ListChannelsOptions::set_has_locale() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ListChannelsOptions::clear_has_locale() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ListChannelsOptions::clear_locale() {
  locale_ = 0u;
  clear_has_locale();
}
inline ::google::protobuf::uint32 ListChannelsOptions::locale() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.locale)
  return locale_;
}
inline void ListChannelsOptions::set_locale(::google::protobuf::uint32 value) {
  set_has_locale();
  locale_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.locale)
}

// optional uint32 capacity_full = 6;
inline bool ListChannelsOptions::has_capacity_full() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ListChannelsOptions::set_has_capacity_full() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ListChannelsOptions::clear_has_capacity_full() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ListChannelsOptions::clear_capacity_full() {
  capacity_full_ = 0u;
  clear_has_capacity_full();
}
inline ::google::protobuf::uint32 ListChannelsOptions::capacity_full() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.capacity_full)
  return capacity_full_;
}
inline void ListChannelsOptions::set_capacity_full(::google::protobuf::uint32 value) {
  set_has_capacity_full();
  capacity_full_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.capacity_full)
}

// required .bgs.protocol.AttributeFilter attribute_filter = 7;
inline bool ListChannelsOptions::has_attribute_filter() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ListChannelsOptions::set_has_attribute_filter() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ListChannelsOptions::clear_has_attribute_filter() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ListChannelsOptions::clear_attribute_filter() {
  if (attribute_filter_ != NULL) attribute_filter_->::bgs::protocol::AttributeFilter::Clear();
  clear_has_attribute_filter();
}
inline const ::bgs::protocol::AttributeFilter& ListChannelsOptions::attribute_filter() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.attribute_filter)
  return attribute_filter_ != NULL ? *attribute_filter_ : *default_instance_->attribute_filter_;
}
inline ::bgs::protocol::AttributeFilter* ListChannelsOptions::mutable_attribute_filter() {
  set_has_attribute_filter();
  if (attribute_filter_ == NULL) attribute_filter_ = new ::bgs::protocol::AttributeFilter;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ListChannelsOptions.attribute_filter)
  return attribute_filter_;
}
inline ::bgs::protocol::AttributeFilter* ListChannelsOptions::release_attribute_filter() {
  clear_has_attribute_filter();
  ::bgs::protocol::AttributeFilter* temp = attribute_filter_;
  attribute_filter_ = NULL;
  return temp;
}
inline void ListChannelsOptions::set_allocated_attribute_filter(::bgs::protocol::AttributeFilter* attribute_filter) {
  delete attribute_filter_;
  attribute_filter_ = attribute_filter;
  if (attribute_filter) {
    set_has_attribute_filter();
  } else {
    clear_has_attribute_filter();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ListChannelsOptions.attribute_filter)
}

// optional string channel_type = 8;
inline bool ListChannelsOptions::has_channel_type() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ListChannelsOptions::set_has_channel_type() {
  _has_bits_[0] |= 0x00000080u;
}
inline void ListChannelsOptions::clear_has_channel_type() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void ListChannelsOptions::clear_channel_type() {
  if (channel_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    channel_type_->clear();
  }
  clear_has_channel_type();
}
inline const ::std::string& ListChannelsOptions::channel_type() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ListChannelsOptions.channel_type)
  return *channel_type_;
}
inline void ListChannelsOptions::set_channel_type(const ::std::string& value) {
  set_has_channel_type();
  if (channel_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    channel_type_ = new ::std::string;
  }
  channel_type_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ListChannelsOptions.channel_type)
}
inline void ListChannelsOptions::set_channel_type(const char* value) {
  set_has_channel_type();
  if (channel_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    channel_type_ = new ::std::string;
  }
  channel_type_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.ListChannelsOptions.channel_type)
}
inline void ListChannelsOptions::set_channel_type(const char* value, size_t size) {
  set_has_channel_type();
  if (channel_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    channel_type_ = new ::std::string;
  }
  channel_type_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.ListChannelsOptions.channel_type)
}
inline ::std::string* ListChannelsOptions::mutable_channel_type() {
  set_has_channel_type();
  if (channel_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    channel_type_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ListChannelsOptions.channel_type)
  return channel_type_;
}
inline ::std::string* ListChannelsOptions::release_channel_type() {
  clear_has_channel_type();
  if (channel_type_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = channel_type_;
    channel_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void ListChannelsOptions::set_allocated_channel_type(::std::string* channel_type) {
  if (channel_type_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete channel_type_;
  }
  if (channel_type) {
    set_has_channel_type();
    channel_type_ = channel_type;
  } else {
    clear_has_channel_type();
    channel_type_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ListChannelsOptions.channel_type)
}

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

// ChannelDescription

// required .bgs.protocol.EntityId channel_id = 1;
inline bool ChannelDescription::has_channel_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ChannelDescription::set_has_channel_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ChannelDescription::clear_has_channel_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ChannelDescription::clear_channel_id() {
  if (channel_id_ != NULL) channel_id_->::bgs::protocol::EntityId::Clear();
  clear_has_channel_id();
}
inline const ::bgs::protocol::EntityId& ChannelDescription::channel_id() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelDescription.channel_id)
  return channel_id_ != NULL ? *channel_id_ : *default_instance_->channel_id_;
}
inline ::bgs::protocol::EntityId* ChannelDescription::mutable_channel_id() {
  set_has_channel_id();
  if (channel_id_ == NULL) channel_id_ = new ::bgs::protocol::EntityId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelDescription.channel_id)
  return channel_id_;
}
inline ::bgs::protocol::EntityId* ChannelDescription::release_channel_id() {
  clear_has_channel_id();
  ::bgs::protocol::EntityId* temp = channel_id_;
  channel_id_ = NULL;
  return temp;
}
inline void ChannelDescription::set_allocated_channel_id(::bgs::protocol::EntityId* channel_id) {
  delete channel_id_;
  channel_id_ = channel_id;
  if (channel_id) {
    set_has_channel_id();
  } else {
    clear_has_channel_id();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelDescription.channel_id)
}

// optional uint32 current_members = 2;
inline bool ChannelDescription::has_current_members() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ChannelDescription::set_has_current_members() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ChannelDescription::clear_has_current_members() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ChannelDescription::clear_current_members() {
  current_members_ = 0u;
  clear_has_current_members();
}
inline ::google::protobuf::uint32 ChannelDescription::current_members() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelDescription.current_members)
  return current_members_;
}
inline void ChannelDescription::set_current_members(::google::protobuf::uint32 value) {
  set_has_current_members();
  current_members_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelDescription.current_members)
}

// optional .bgs.protocol.channel.v1.ChannelState state = 3;
inline bool ChannelDescription::has_state() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ChannelDescription::set_has_state() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ChannelDescription::clear_has_state() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ChannelDescription::clear_state() {
  if (state_ != NULL) state_->::bgs::protocol::channel::v1::ChannelState::Clear();
  clear_has_state();
}
inline const ::bgs::protocol::channel::v1::ChannelState& ChannelDescription::state() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelDescription.state)
  return state_ != NULL ? *state_ : *default_instance_->state_;
}
inline ::bgs::protocol::channel::v1::ChannelState* ChannelDescription::mutable_state() {
  set_has_state();
  if (state_ == NULL) state_ = new ::bgs::protocol::channel::v1::ChannelState;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelDescription.state)
  return state_;
}
inline ::bgs::protocol::channel::v1::ChannelState* ChannelDescription::release_state() {
  clear_has_state();
  ::bgs::protocol::channel::v1::ChannelState* temp = state_;
  state_ = NULL;
  return temp;
}
inline void ChannelDescription::set_allocated_state(::bgs::protocol::channel::v1::ChannelState* state) {
  delete state_;
  state_ = state;
  if (state) {
    set_has_state();
  } else {
    clear_has_state();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelDescription.state)
}

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

// ChannelInfo

// required .bgs.protocol.channel.v1.ChannelDescription description = 1;
inline bool ChannelInfo::has_description() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ChannelInfo::set_has_description() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ChannelInfo::clear_has_description() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ChannelInfo::clear_description() {
  if (description_ != NULL) description_->::bgs::protocol::channel::v1::ChannelDescription::Clear();
  clear_has_description();
}
inline const ::bgs::protocol::channel::v1::ChannelDescription& ChannelInfo::description() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelInfo.description)
  return description_ != NULL ? *description_ : *default_instance_->description_;
}
inline ::bgs::protocol::channel::v1::ChannelDescription* ChannelInfo::mutable_description() {
  set_has_description();
  if (description_ == NULL) description_ = new ::bgs::protocol::channel::v1::ChannelDescription;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelInfo.description)
  return description_;
}
inline ::bgs::protocol::channel::v1::ChannelDescription* ChannelInfo::release_description() {
  clear_has_description();
  ::bgs::protocol::channel::v1::ChannelDescription* temp = description_;
  description_ = NULL;
  return temp;
}
inline void ChannelInfo::set_allocated_description(::bgs::protocol::channel::v1::ChannelDescription* description) {
  delete description_;
  description_ = description;
  if (description) {
    set_has_description();
  } else {
    clear_has_description();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelInfo.description)
}

// repeated .bgs.protocol.channel.v1.Member member = 2;
inline int ChannelInfo::member_size() const {
  return member_.size();
}
inline void ChannelInfo::clear_member() {
  member_.Clear();
}
inline const ::bgs::protocol::channel::v1::Member& ChannelInfo::member(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelInfo.member)
  return member_.Get(index);
}
inline ::bgs::protocol::channel::v1::Member* ChannelInfo::mutable_member(int index) {
  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelInfo.member)
  return member_.Mutable(index);
}
inline ::bgs::protocol::channel::v1::Member* ChannelInfo::add_member() {
  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.ChannelInfo.member)
  return member_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >&
ChannelInfo::member() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.ChannelInfo.member)
  return member_;
}
inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::channel::v1::Member >*
ChannelInfo::mutable_member() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.ChannelInfo.member)
  return &member_;
}

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

// ChannelState

// optional uint32 max_members = 1;
inline bool ChannelState::has_max_members() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ChannelState::set_has_max_members() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ChannelState::clear_has_max_members() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ChannelState::clear_max_members() {
  max_members_ = 0u;
  clear_has_max_members();
}
inline ::google::protobuf::uint32 ChannelState::max_members() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.max_members)
  return max_members_;
}
inline void ChannelState::set_max_members(::google::protobuf::uint32 value) {
  set_has_max_members();
  max_members_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.max_members)
}

// optional uint32 min_members = 2;
inline bool ChannelState::has_min_members() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ChannelState::set_has_min_members() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ChannelState::clear_has_min_members() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ChannelState::clear_min_members() {
  min_members_ = 0u;
  clear_has_min_members();
}
inline ::google::protobuf::uint32 ChannelState::min_members() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.min_members)
  return min_members_;
}
inline void ChannelState::set_min_members(::google::protobuf::uint32 value) {
  set_has_min_members();
  min_members_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.min_members)
}

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

// repeated .bgs.protocol.Invitation invitation = 4;
inline int ChannelState::invitation_size() const {
  return invitation_.size();
}
inline void ChannelState::clear_invitation() {
  invitation_.Clear();
}
inline const ::bgs::protocol::Invitation& ChannelState::invitation(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.invitation)
  return invitation_.Get(index);
}
inline ::bgs::protocol::Invitation* ChannelState::mutable_invitation(int index) {
  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelState.invitation)
  return invitation_.Mutable(index);
}
inline ::bgs::protocol::Invitation* ChannelState::add_invitation() {
  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.ChannelState.invitation)
  return invitation_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >&
ChannelState::invitation() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.ChannelState.invitation)
  return invitation_;
}
inline ::google::protobuf::RepeatedPtrField< ::bgs::protocol::Invitation >*
ChannelState::mutable_invitation() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.ChannelState.invitation)
  return &invitation_;
}

// optional uint32 reason = 6;
inline bool ChannelState::has_reason() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ChannelState::set_has_reason() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ChannelState::clear_has_reason() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ChannelState::clear_reason() {
  reason_ = 0u;
  clear_has_reason();
}
inline ::google::protobuf::uint32 ChannelState::reason() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.reason)
  return reason_;
}
inline void ChannelState::set_reason(::google::protobuf::uint32 value) {
  set_has_reason();
  reason_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.reason)
}

// optional .bgs.protocol.channel.v1.ChannelState.PrivacyLevel privacy_level = 7 [default = PRIVACY_LEVEL_OPEN];
inline bool ChannelState::has_privacy_level() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ChannelState::set_has_privacy_level() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ChannelState::clear_has_privacy_level() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ChannelState::clear_privacy_level() {
  privacy_level_ = 1;
  clear_has_privacy_level();
}
inline ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel ChannelState::privacy_level() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.privacy_level)
  return static_cast< ::bgs::protocol::channel::v1::ChannelState_PrivacyLevel >(privacy_level_);
}
inline void ChannelState::set_privacy_level(::bgs::protocol::channel::v1::ChannelState_PrivacyLevel value) {
  assert(::bgs::protocol::channel::v1::ChannelState_PrivacyLevel_IsValid(value));
  set_has_privacy_level();
  privacy_level_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.privacy_level)
}

// optional string name = 8;
inline bool ChannelState::has_name() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ChannelState::set_has_name() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ChannelState::clear_has_name() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ChannelState::clear_name() {
  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    name_->clear();
  }
  clear_has_name();
}
inline const ::std::string& ChannelState::name() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.name)
  return *name_;
}
inline void ChannelState::set_name(const ::std::string& value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    name_ = new ::std::string;
  }
  name_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.name)
}
inline void ChannelState::set_name(const char* value) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    name_ = new ::std::string;
  }
  name_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.ChannelState.name)
}
inline void ChannelState::set_name(const char* value, size_t size) {
  set_has_name();
  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.ChannelState.name)
}
inline ::std::string* ChannelState::mutable_name() {
  set_has_name();
  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    name_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelState.name)
  return name_;
}
inline ::std::string* ChannelState::release_name() {
  clear_has_name();
  if (name_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = name_;
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void ChannelState::set_allocated_name(::std::string* name) {
  if (name_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete name_;
  }
  if (name) {
    set_has_name();
    name_ = name;
  } else {
    clear_has_name();
    name_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelState.name)
}

// optional string channel_type = 10 [default = "default"];
inline bool ChannelState::has_channel_type() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ChannelState::set_has_channel_type() {
  _has_bits_[0] |= 0x00000080u;
}
inline void ChannelState::clear_has_channel_type() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void ChannelState::clear_channel_type() {
  if (channel_type_ != _default_channel_type_) {
    channel_type_->assign(*_default_channel_type_);
  }
  clear_has_channel_type();
}
inline const ::std::string& ChannelState::channel_type() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.channel_type)
  return *channel_type_;
}
inline void ChannelState::set_channel_type(const ::std::string& value) {
  set_has_channel_type();
  if (channel_type_ == _default_channel_type_) {
    channel_type_ = new ::std::string;
  }
  channel_type_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.channel_type)
}
inline void ChannelState::set_channel_type(const char* value) {
  set_has_channel_type();
  if (channel_type_ == _default_channel_type_) {
    channel_type_ = new ::std::string;
  }
  channel_type_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.channel.v1.ChannelState.channel_type)
}
inline void ChannelState::set_channel_type(const char* value, size_t size) {
  set_has_channel_type();
  if (channel_type_ == _default_channel_type_) {
    channel_type_ = new ::std::string;
  }
  channel_type_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.channel.v1.ChannelState.channel_type)
}
inline ::std::string* ChannelState::mutable_channel_type() {
  set_has_channel_type();
  if (channel_type_ == _default_channel_type_) {
    channel_type_ = new ::std::string(*_default_channel_type_);
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.ChannelState.channel_type)
  return channel_type_;
}
inline ::std::string* ChannelState::release_channel_type() {
  clear_has_channel_type();
  if (channel_type_ == _default_channel_type_) {
    return NULL;
  } else {
    ::std::string* temp = channel_type_;
    channel_type_ = const_cast< ::std::string*>(_default_channel_type_);
    return temp;
  }
}
inline void ChannelState::set_allocated_channel_type(::std::string* channel_type) {
  if (channel_type_ != _default_channel_type_) {
    delete channel_type_;
  }
  if (channel_type) {
    set_has_channel_type();
    channel_type_ = channel_type;
  } else {
    clear_has_channel_type();
    channel_type_ = const_cast< ::std::string*>(_default_channel_type_);
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.ChannelState.channel_type)
}

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

// optional bool subscribe_to_presence = 13 [default = true];
inline bool ChannelState::has_subscribe_to_presence() const {
  return (_has_bits_[0] & 0x00000200u) != 0;
}
inline void ChannelState::set_has_subscribe_to_presence() {
  _has_bits_[0] |= 0x00000200u;
}
inline void ChannelState::clear_has_subscribe_to_presence() {
  _has_bits_[0] &= ~0x00000200u;
}
inline void ChannelState::clear_subscribe_to_presence() {
  subscribe_to_presence_ = true;
  clear_has_subscribe_to_presence();
}
inline bool ChannelState::subscribe_to_presence() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.ChannelState.subscribe_to_presence)
  return subscribe_to_presence_;
}
inline void ChannelState::set_subscribe_to_presence(bool value) {
  set_has_subscribe_to_presence();
  subscribe_to_presence_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.ChannelState.subscribe_to_presence)
}

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

// MemberAccountInfo

// optional string battle_tag = 3;
inline bool MemberAccountInfo::has_battle_tag() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MemberAccountInfo::set_has_battle_tag() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MemberAccountInfo::clear_has_battle_tag() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MemberAccountInfo::clear_battle_tag() {
  if (battle_tag_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    battle_tag_->clear();
  }
  clear_has_battle_tag();
}
inline const ::std::string& MemberAccountInfo::battle_tag() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberAccountInfo.battle_tag)
  return *battle_tag_;
}
inline void MemberAccountInfo::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.channel.v1.MemberAccountInfo.battle_tag)
}
inline void MemberAccountInfo::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.channel.v1.MemberAccountInfo.battle_tag)
}
inline void MemberAccountInfo::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.channel.v1.MemberAccountInfo.battle_tag)
}
inline ::std::string* MemberAccountInfo::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.channel.v1.MemberAccountInfo.battle_tag)
  return battle_tag_;
}
inline ::std::string* MemberAccountInfo::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 MemberAccountInfo::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.channel.v1.MemberAccountInfo.battle_tag)
}

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

// MemberState

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

// repeated uint32 role = 2 [packed = true];
inline int MemberState::role_size() const {
  return role_.size();
}
inline void MemberState::clear_role() {
  role_.Clear();
}
inline ::google::protobuf::uint32 MemberState::role(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberState.role)
  return role_.Get(index);
}
inline void MemberState::set_role(int index, ::google::protobuf::uint32 value) {
  role_.Set(index, value);
  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.MemberState.role)
}
inline void MemberState::add_role(::google::protobuf::uint32 value) {
  role_.Add(value);
  // @@protoc_insertion_point(field_add:bgs.protocol.channel.v1.MemberState.role)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
MemberState::role() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.channel.v1.MemberState.role)
  return role_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
MemberState::mutable_role() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.channel.v1.MemberState.role)
  return &role_;
}

// optional uint64 privileges = 3 [default = 0];
inline bool MemberState::has_privileges() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void MemberState::set_has_privileges() {
  _has_bits_[0] |= 0x00000004u;
}
inline void MemberState::clear_has_privileges() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void MemberState::clear_privileges() {
  privileges_ = GOOGLE_ULONGLONG(0);
  clear_has_privileges();
}
inline ::google::protobuf::uint64 MemberState::privileges() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberState.privileges)
  return privileges_;
}
inline void MemberState::set_privileges(::google::protobuf::uint64 value) {
  set_has_privileges();
  privileges_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.channel.v1.MemberState.privileges)
}

// optional .bgs.protocol.channel.v1.MemberAccountInfo info = 4;
inline bool MemberState::has_info() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void MemberState::set_has_info() {
  _has_bits_[0] |= 0x00000008u;
}
inline void MemberState::clear_has_info() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void MemberState::clear_info() {
  if (info_ != NULL) info_->::bgs::protocol::channel::v1::MemberAccountInfo::Clear();
  clear_has_info();
}
inline const ::bgs::protocol::channel::v1::MemberAccountInfo& MemberState::info() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.MemberState.info)
  return info_ != NULL ? *info_ : *default_instance_->info_;
}
inline ::bgs::protocol::channel::v1::MemberAccountInfo* MemberState::mutable_info() {
  set_has_info();
  if (info_ == NULL) info_ = new ::bgs::protocol::channel::v1::MemberAccountInfo;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.MemberState.info)
  return info_;
}
inline ::bgs::protocol::channel::v1::MemberAccountInfo* MemberState::release_info() {
  clear_has_info();
  ::bgs::protocol::channel::v1::MemberAccountInfo* temp = info_;
  info_ = NULL;
  return temp;
}
inline void MemberState::set_allocated_info(::bgs::protocol::channel::v1::MemberAccountInfo* info) {
  delete info_;
  info_ = info;
  if (info) {
    set_has_info();
  } else {
    clear_has_info();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.MemberState.info)
}

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

// Member

// required .bgs.protocol.Identity identity = 1;
inline bool Member::has_identity() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Member::set_has_identity() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Member::clear_has_identity() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Member::clear_identity() {
  if (identity_ != NULL) identity_->::bgs::protocol::Identity::Clear();
  clear_has_identity();
}
inline const ::bgs::protocol::Identity& Member::identity() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.Member.identity)
  return identity_ != NULL ? *identity_ : *default_instance_->identity_;
}
inline ::bgs::protocol::Identity* Member::mutable_identity() {
  set_has_identity();
  if (identity_ == NULL) identity_ = new ::bgs::protocol::Identity;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.Member.identity)
  return identity_;
}
inline ::bgs::protocol::Identity* Member::release_identity() {
  clear_has_identity();
  ::bgs::protocol::Identity* temp = identity_;
  identity_ = NULL;
  return temp;
}
inline void Member::set_allocated_identity(::bgs::protocol::Identity* identity) {
  delete identity_;
  identity_ = identity;
  if (identity) {
    set_has_identity();
  } else {
    clear_has_identity();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.Member.identity)
}

// required .bgs.protocol.channel.v1.MemberState state = 2;
inline bool Member::has_state() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Member::set_has_state() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Member::clear_has_state() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void Member::clear_state() {
  if (state_ != NULL) state_->::bgs::protocol::channel::v1::MemberState::Clear();
  clear_has_state();
}
inline const ::bgs::protocol::channel::v1::MemberState& Member::state() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.Member.state)
  return state_ != NULL ? *state_ : *default_instance_->state_;
}
inline ::bgs::protocol::channel::v1::MemberState* Member::mutable_state() {
  set_has_state();
  if (state_ == NULL) state_ = new ::bgs::protocol::channel::v1::MemberState;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.Member.state)
  return state_;
}
inline ::bgs::protocol::channel::v1::MemberState* Member::release_state() {
  clear_has_state();
  ::bgs::protocol::channel::v1::MemberState* temp = state_;
  state_ = NULL;
  return temp;
}
inline void Member::set_allocated_state(::bgs::protocol::channel::v1::MemberState* state) {
  delete state_;
  state_ = state;
  if (state) {
    set_has_state();
  } else {
    clear_has_state();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.Member.state)
}

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

// SubscriberId

// optional .bgs.protocol.account.v1.AccountId account = 1 [deprecated = true];
inline bool SubscriberId::has_account() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SubscriberId::set_has_account() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SubscriberId::clear_has_account() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SubscriberId::clear_account() {
  if (account_ != NULL) account_->::bgs::protocol::account::v1::AccountId::Clear();
  clear_has_account();
}
inline const ::bgs::protocol::account::v1::AccountId& SubscriberId::account() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SubscriberId.account)
  return account_ != NULL ? *account_ : *default_instance_->account_;
}
inline ::bgs::protocol::account::v1::AccountId* SubscriberId::mutable_account() {
  set_has_account();
  if (account_ == NULL) account_ = new ::bgs::protocol::account::v1::AccountId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SubscriberId.account)
  return account_;
}
inline ::bgs::protocol::account::v1::AccountId* SubscriberId::release_account() {
  clear_has_account();
  ::bgs::protocol::account::v1::AccountId* temp = account_;
  account_ = NULL;
  return temp;
}
inline void SubscriberId::set_allocated_account(::bgs::protocol::account::v1::AccountId* account) {
  delete account_;
  account_ = account;
  if (account) {
    set_has_account();
  } else {
    clear_has_account();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SubscriberId.account)
}

// optional .bgs.protocol.account.v1.GameAccountHandle game_account = 2;
inline bool SubscriberId::has_game_account() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SubscriberId::set_has_game_account() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SubscriberId::clear_has_game_account() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SubscriberId::clear_game_account() {
  if (game_account_ != NULL) game_account_->::bgs::protocol::account::v1::GameAccountHandle::Clear();
  clear_has_game_account();
}
inline const ::bgs::protocol::account::v1::GameAccountHandle& SubscriberId::game_account() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SubscriberId.game_account)
  return game_account_ != NULL ? *game_account_ : *default_instance_->game_account_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* SubscriberId::mutable_game_account() {
  set_has_game_account();
  if (game_account_ == NULL) game_account_ = new ::bgs::protocol::account::v1::GameAccountHandle;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SubscriberId.game_account)
  return game_account_;
}
inline ::bgs::protocol::account::v1::GameAccountHandle* SubscriberId::release_game_account() {
  clear_has_game_account();
  ::bgs::protocol::account::v1::GameAccountHandle* temp = game_account_;
  game_account_ = NULL;
  return temp;
}
inline void SubscriberId::set_allocated_game_account(::bgs::protocol::account::v1::GameAccountHandle* game_account) {
  delete game_account_;
  game_account_ = game_account;
  if (game_account) {
    set_has_game_account();
  } else {
    clear_has_game_account();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SubscriberId.game_account)
}

// optional .bgs.protocol.ProcessId process = 3;
inline bool SubscriberId::has_process() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SubscriberId::set_has_process() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SubscriberId::clear_has_process() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SubscriberId::clear_process() {
  if (process_ != NULL) process_->::bgs::protocol::ProcessId::Clear();
  clear_has_process();
}
inline const ::bgs::protocol::ProcessId& SubscriberId::process() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.channel.v1.SubscriberId.process)
  return process_ != NULL ? *process_ : *default_instance_->process_;
}
inline ::bgs::protocol::ProcessId* SubscriberId::mutable_process() {
  set_has_process();
  if (process_ == NULL) process_ = new ::bgs::protocol::ProcessId;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.channel.v1.SubscriberId.process)
  return process_;
}
inline ::bgs::protocol::ProcessId* SubscriberId::release_process() {
  clear_has_process();
  ::bgs::protocol::ProcessId* temp = process_;
  process_ = NULL;
  return temp;
}
inline void SubscriberId::set_allocated_process(::bgs::protocol::ProcessId* process) {
  delete process_;
  process_ = process;
  if (process) {
    set_has_process();
  } else {
    clear_has_process();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.channel.v1.SubscriberId.process)
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace v1
}  // namespace channel
}  // namespace protocol
}  // namespace bgs

#ifndef SWIG
namespace google {
namespace protobuf {

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

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

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_channel_5ftypes_2eproto__INCLUDED
