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

#ifndef PROTOBUF_dialogs_2eproto__INCLUDED
#define PROTOBUF_dialogs_2eproto__INCLUDED

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 3001000
#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 3001000 < 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/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/unknown_field_set.h>
#include "messaging_base.pb.h"
#include "group_base.pb.h"
#include "peers.pb.h"
#include "users.pb.h"
// @@protoc_insertion_point(includes)

namespace zproto {

// Internal implementation detail -- do not call these.
void protobuf_AddDesc_dialogs_2eproto();
void protobuf_InitDefaults_dialogs_2eproto();
void protobuf_AssignDesc_dialogs_2eproto();
void protobuf_ShutdownFile_dialogs_2eproto();

class BlockPeerReq;
class CreateChatDialogReq;
class CreateChatDialogRsp;
class Dialog;
class DndPeerReq;
class LoadBlockedPeersReq;
class LoadBlockedPeersRsp;
class LoadDialogsReq;
class LoadDialogsRsp;
class LoadDndedPeersReq;
class LoadDndedPeersRsp;
class LoadTopedPeersReq;
class LoadTopedPeersRsp;
class PeerBlockedNotify;
class PeerDndedNotify;
class PeerTopedNotify;
class PeerUnblockedNotify;
class PeerUndndedNotify;
class PeerUntopedNotify;
class TopPeerReq;
class UnblockPeerReq;
class UndndPeerReq;
class UntopPeerReq;

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

class Dialog : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.Dialog) */ {
 public:
  Dialog();
  virtual ~Dialog();

  Dialog(const Dialog& from);

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

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

  static const Dialog* internal_default_instance();

  void Swap(Dialog* other);

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

  inline Dialog* New() const { return New(NULL); }

  Dialog* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Dialog* other);
  void UnsafeMergeFrom(const Dialog& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional .zproto.Peer peer = 1;
  bool has_peer() const;
  void clear_peer();
  static const int kPeerFieldNumber = 1;
  const ::zproto::Peer& peer() const;
  ::zproto::Peer* mutable_peer();
  ::zproto::Peer* release_peer();
  void set_allocated_peer(::zproto::Peer* peer);

  // optional int32 unread_count = 2;
  void clear_unread_count();
  static const int kUnreadCountFieldNumber = 2;
  ::google::protobuf::int32 unread_count() const;
  void set_unread_count(::google::protobuf::int32 value);

  // optional int64 sort_date = 3;
  void clear_sort_date();
  static const int kSortDateFieldNumber = 3;
  ::google::protobuf::int64 sort_date() const;
  void set_sort_date(::google::protobuf::int64 value);

  // optional .zproto.MessageContainer last_message = 4;
  bool has_last_message() const;
  void clear_last_message();
  static const int kLastMessageFieldNumber = 4;
  const ::zproto::MessageContainer& last_message() const;
  ::zproto::MessageContainer* mutable_last_message();
  ::zproto::MessageContainer* release_last_message();
  void set_allocated_last_message(::zproto::MessageContainer* last_message);

  // optional int64 first_unread_date = 5;
  void clear_first_unread_date();
  static const int kFirstUnreadDateFieldNumber = 5;
  ::google::protobuf::int64 first_unread_date() const;
  void set_first_unread_date(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:zproto.Dialog)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::zproto::Peer* peer_;
  ::zproto::MessageContainer* last_message_;
  ::google::protobuf::int64 sort_date_;
  ::google::protobuf::int64 first_unread_date_;
  ::google::protobuf::int32 unread_count_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<Dialog> Dialog_default_instance_;

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

class LoadDialogsReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.LoadDialogsReq) */ {
 public:
  LoadDialogsReq();
  virtual ~LoadDialogsReq();

  LoadDialogsReq(const LoadDialogsReq& from);

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

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

  static const LoadDialogsReq* internal_default_instance();

  void Swap(LoadDialogsReq* other);

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

  inline LoadDialogsReq* New() const { return New(NULL); }

  LoadDialogsReq* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LoadDialogsReq* other);
  void UnsafeMergeFrom(const LoadDialogsReq& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional int64 min_date = 1;
  void clear_min_date();
  static const int kMinDateFieldNumber = 1;
  ::google::protobuf::int64 min_date() const;
  void set_min_date(::google::protobuf::int64 value);

  // optional .zproto.ListLoadMode load_mode = 2;
  void clear_load_mode();
  static const int kLoadModeFieldNumber = 2;
  ::zproto::ListLoadMode load_mode() const;
  void set_load_mode(::zproto::ListLoadMode value);

  // optional int32 limit = 3;
  void clear_limit();
  static const int kLimitFieldNumber = 3;
  ::google::protobuf::int32 limit() const;
  void set_limit(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:zproto.LoadDialogsReq)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int64 min_date_;
  int load_mode_;
  ::google::protobuf::int32 limit_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<LoadDialogsReq> LoadDialogsReq_default_instance_;

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

class LoadDialogsRsp : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.LoadDialogsRsp) */ {
 public:
  LoadDialogsRsp();
  virtual ~LoadDialogsRsp();

  LoadDialogsRsp(const LoadDialogsRsp& from);

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

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

  static const LoadDialogsRsp* internal_default_instance();

  void Swap(LoadDialogsRsp* other);

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

  inline LoadDialogsRsp* New() const { return New(NULL); }

  LoadDialogsRsp* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LoadDialogsRsp* other);
  void UnsafeMergeFrom(const LoadDialogsRsp& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // repeated .zproto.Group groups = 1;
  int groups_size() const;
  void clear_groups();
  static const int kGroupsFieldNumber = 1;
  const ::zproto::Group& groups(int index) const;
  ::zproto::Group* mutable_groups(int index);
  ::zproto::Group* add_groups();
  ::google::protobuf::RepeatedPtrField< ::zproto::Group >*
      mutable_groups();
  const ::google::protobuf::RepeatedPtrField< ::zproto::Group >&
      groups() const;

  // repeated .zproto.User users = 2;
  int users_size() const;
  void clear_users();
  static const int kUsersFieldNumber = 2;
  const ::zproto::User& users(int index) const;
  ::zproto::User* mutable_users(int index);
  ::zproto::User* add_users();
  ::google::protobuf::RepeatedPtrField< ::zproto::User >*
      mutable_users();
  const ::google::protobuf::RepeatedPtrField< ::zproto::User >&
      users() const;

  // repeated .zproto.Dialog dialogs = 3;
  int dialogs_size() const;
  void clear_dialogs();
  static const int kDialogsFieldNumber = 3;
  const ::zproto::Dialog& dialogs(int index) const;
  ::zproto::Dialog* mutable_dialogs(int index);
  ::zproto::Dialog* add_dialogs();
  ::google::protobuf::RepeatedPtrField< ::zproto::Dialog >*
      mutable_dialogs();
  const ::google::protobuf::RepeatedPtrField< ::zproto::Dialog >&
      dialogs() const;

  // repeated .zproto.UserOutPeer user_peers = 4;
  int user_peers_size() const;
  void clear_user_peers();
  static const int kUserPeersFieldNumber = 4;
  const ::zproto::UserOutPeer& user_peers(int index) const;
  ::zproto::UserOutPeer* mutable_user_peers(int index);
  ::zproto::UserOutPeer* add_user_peers();
  ::google::protobuf::RepeatedPtrField< ::zproto::UserOutPeer >*
      mutable_user_peers();
  const ::google::protobuf::RepeatedPtrField< ::zproto::UserOutPeer >&
      user_peers() const;

  // repeated .zproto.GroupOutPeer group_peers = 5;
  int group_peers_size() const;
  void clear_group_peers();
  static const int kGroupPeersFieldNumber = 5;
  const ::zproto::GroupOutPeer& group_peers(int index) const;
  ::zproto::GroupOutPeer* mutable_group_peers(int index);
  ::zproto::GroupOutPeer* add_group_peers();
  ::google::protobuf::RepeatedPtrField< ::zproto::GroupOutPeer >*
      mutable_group_peers();
  const ::google::protobuf::RepeatedPtrField< ::zproto::GroupOutPeer >&
      group_peers() const;

  // @@protoc_insertion_point(class_scope:zproto.LoadDialogsRsp)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::zproto::Group > groups_;
  ::google::protobuf::RepeatedPtrField< ::zproto::User > users_;
  ::google::protobuf::RepeatedPtrField< ::zproto::Dialog > dialogs_;
  ::google::protobuf::RepeatedPtrField< ::zproto::UserOutPeer > user_peers_;
  ::google::protobuf::RepeatedPtrField< ::zproto::GroupOutPeer > group_peers_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<LoadDialogsRsp> LoadDialogsRsp_default_instance_;

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

class CreateChatDialogReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.CreateChatDialogReq) */ {
 public:
  CreateChatDialogReq();
  virtual ~CreateChatDialogReq();

  CreateChatDialogReq(const CreateChatDialogReq& from);

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

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

  static const CreateChatDialogReq* internal_default_instance();

  void Swap(CreateChatDialogReq* other);

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

  inline CreateChatDialogReq* New() const { return New(NULL); }

  CreateChatDialogReq* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(CreateChatDialogReq* other);
  void UnsafeMergeFrom(const CreateChatDialogReq& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional string peer_id = 1;
  void clear_peer_id();
  static const int kPeerIdFieldNumber = 1;
  const ::std::string& peer_id() const;
  void set_peer_id(const ::std::string& value);
  void set_peer_id(const char* value);
  void set_peer_id(const char* value, size_t size);
  ::std::string* mutable_peer_id();
  ::std::string* release_peer_id();
  void set_allocated_peer_id(::std::string* peer_id);

  // @@protoc_insertion_point(class_scope:zproto.CreateChatDialogReq)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr peer_id_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<CreateChatDialogReq> CreateChatDialogReq_default_instance_;

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

class CreateChatDialogRsp : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.CreateChatDialogRsp) */ {
 public:
  CreateChatDialogRsp();
  virtual ~CreateChatDialogRsp();

  CreateChatDialogRsp(const CreateChatDialogRsp& from);

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

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

  static const CreateChatDialogRsp* internal_default_instance();

  void Swap(CreateChatDialogRsp* other);

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

  inline CreateChatDialogRsp* New() const { return New(NULL); }

  CreateChatDialogRsp* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(CreateChatDialogRsp* other);
  void UnsafeMergeFrom(const CreateChatDialogRsp& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional .zproto.OutPeer peer = 1;
  bool has_peer() const;
  void clear_peer();
  static const int kPeerFieldNumber = 1;
  const ::zproto::OutPeer& peer() const;
  ::zproto::OutPeer* mutable_peer();
  ::zproto::OutPeer* release_peer();
  void set_allocated_peer(::zproto::OutPeer* peer);

  // @@protoc_insertion_point(class_scope:zproto.CreateChatDialogRsp)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::zproto::OutPeer* peer_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<CreateChatDialogRsp> CreateChatDialogRsp_default_instance_;

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

class BlockPeerReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.BlockPeerReq) */ {
 public:
  BlockPeerReq();
  virtual ~BlockPeerReq();

  BlockPeerReq(const BlockPeerReq& from);

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

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

  static const BlockPeerReq* internal_default_instance();

  void Swap(BlockPeerReq* other);

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

  inline BlockPeerReq* New() const { return New(NULL); }

  BlockPeerReq* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(BlockPeerReq* other);
  void UnsafeMergeFrom(const BlockPeerReq& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional .zproto.OutPeer peer = 1;
  bool has_peer() const;
  void clear_peer();
  static const int kPeerFieldNumber = 1;
  const ::zproto::OutPeer& peer() const;
  ::zproto::OutPeer* mutable_peer();
  ::zproto::OutPeer* release_peer();
  void set_allocated_peer(::zproto::OutPeer* peer);

  // @@protoc_insertion_point(class_scope:zproto.BlockPeerReq)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::zproto::OutPeer* peer_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<BlockPeerReq> BlockPeerReq_default_instance_;

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

class UnblockPeerReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.UnblockPeerReq) */ {
 public:
  UnblockPeerReq();
  virtual ~UnblockPeerReq();

  UnblockPeerReq(const UnblockPeerReq& from);

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

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

  static const UnblockPeerReq* internal_default_instance();

  void Swap(UnblockPeerReq* other);

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

  inline UnblockPeerReq* New() const { return New(NULL); }

  UnblockPeerReq* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(UnblockPeerReq* other);
  void UnsafeMergeFrom(const UnblockPeerReq& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional .zproto.OutPeer peer = 1;
  bool has_peer() const;
  void clear_peer();
  static const int kPeerFieldNumber = 1;
  const ::zproto::OutPeer& peer() const;
  ::zproto::OutPeer* mutable_peer();
  ::zproto::OutPeer* release_peer();
  void set_allocated_peer(::zproto::OutPeer* peer);

  // @@protoc_insertion_point(class_scope:zproto.UnblockPeerReq)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::zproto::OutPeer* peer_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<UnblockPeerReq> UnblockPeerReq_default_instance_;

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

class TopPeerReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.TopPeerReq) */ {
 public:
  TopPeerReq();
  virtual ~TopPeerReq();

  TopPeerReq(const TopPeerReq& from);

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

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

  static const TopPeerReq* internal_default_instance();

  void Swap(TopPeerReq* other);

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

  inline TopPeerReq* New() const { return New(NULL); }

  TopPeerReq* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TopPeerReq* other);
  void UnsafeMergeFrom(const TopPeerReq& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional .zproto.OutPeer peer = 1;
  bool has_peer() const;
  void clear_peer();
  static const int kPeerFieldNumber = 1;
  const ::zproto::OutPeer& peer() const;
  ::zproto::OutPeer* mutable_peer();
  ::zproto::OutPeer* release_peer();
  void set_allocated_peer(::zproto::OutPeer* peer);

  // @@protoc_insertion_point(class_scope:zproto.TopPeerReq)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::zproto::OutPeer* peer_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<TopPeerReq> TopPeerReq_default_instance_;

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

class UntopPeerReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.UntopPeerReq) */ {
 public:
  UntopPeerReq();
  virtual ~UntopPeerReq();

  UntopPeerReq(const UntopPeerReq& from);

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

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

  static const UntopPeerReq* internal_default_instance();

  void Swap(UntopPeerReq* other);

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

  inline UntopPeerReq* New() const { return New(NULL); }

  UntopPeerReq* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(UntopPeerReq* other);
  void UnsafeMergeFrom(const UntopPeerReq& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional .zproto.OutPeer peer = 1;
  bool has_peer() const;
  void clear_peer();
  static const int kPeerFieldNumber = 1;
  const ::zproto::OutPeer& peer() const;
  ::zproto::OutPeer* mutable_peer();
  ::zproto::OutPeer* release_peer();
  void set_allocated_peer(::zproto::OutPeer* peer);

  // @@protoc_insertion_point(class_scope:zproto.UntopPeerReq)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::zproto::OutPeer* peer_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<UntopPeerReq> UntopPeerReq_default_instance_;

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

class DndPeerReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.DndPeerReq) */ {
 public:
  DndPeerReq();
  virtual ~DndPeerReq();

  DndPeerReq(const DndPeerReq& from);

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

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

  static const DndPeerReq* internal_default_instance();

  void Swap(DndPeerReq* other);

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

  inline DndPeerReq* New() const { return New(NULL); }

  DndPeerReq* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(DndPeerReq* other);
  void UnsafeMergeFrom(const DndPeerReq& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional .zproto.OutPeer peer = 1;
  bool has_peer() const;
  void clear_peer();
  static const int kPeerFieldNumber = 1;
  const ::zproto::OutPeer& peer() const;
  ::zproto::OutPeer* mutable_peer();
  ::zproto::OutPeer* release_peer();
  void set_allocated_peer(::zproto::OutPeer* peer);

  // @@protoc_insertion_point(class_scope:zproto.DndPeerReq)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::zproto::OutPeer* peer_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<DndPeerReq> DndPeerReq_default_instance_;

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

class UndndPeerReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.UndndPeerReq) */ {
 public:
  UndndPeerReq();
  virtual ~UndndPeerReq();

  UndndPeerReq(const UndndPeerReq& from);

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

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

  static const UndndPeerReq* internal_default_instance();

  void Swap(UndndPeerReq* other);

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

  inline UndndPeerReq* New() const { return New(NULL); }

  UndndPeerReq* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(UndndPeerReq* other);
  void UnsafeMergeFrom(const UndndPeerReq& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional .zproto.OutPeer peer = 1;
  bool has_peer() const;
  void clear_peer();
  static const int kPeerFieldNumber = 1;
  const ::zproto::OutPeer& peer() const;
  ::zproto::OutPeer* mutable_peer();
  ::zproto::OutPeer* release_peer();
  void set_allocated_peer(::zproto::OutPeer* peer);

  // @@protoc_insertion_point(class_scope:zproto.UndndPeerReq)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::zproto::OutPeer* peer_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<UndndPeerReq> UndndPeerReq_default_instance_;

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

class LoadBlockedPeersReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.LoadBlockedPeersReq) */ {
 public:
  LoadBlockedPeersReq();
  virtual ~LoadBlockedPeersReq();

  LoadBlockedPeersReq(const LoadBlockedPeersReq& from);

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

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

  static const LoadBlockedPeersReq* internal_default_instance();

  void Swap(LoadBlockedPeersReq* other);

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

  inline LoadBlockedPeersReq* New() const { return New(NULL); }

  LoadBlockedPeersReq* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LoadBlockedPeersReq* other);
  void UnsafeMergeFrom(const LoadBlockedPeersReq& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // @@protoc_insertion_point(class_scope:zproto.LoadBlockedPeersReq)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<LoadBlockedPeersReq> LoadBlockedPeersReq_default_instance_;

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

class LoadBlockedPeersRsp : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.LoadBlockedPeersRsp) */ {
 public:
  LoadBlockedPeersRsp();
  virtual ~LoadBlockedPeersRsp();

  LoadBlockedPeersRsp(const LoadBlockedPeersRsp& from);

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

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

  static const LoadBlockedPeersRsp* internal_default_instance();

  void Swap(LoadBlockedPeersRsp* other);

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

  inline LoadBlockedPeersRsp* New() const { return New(NULL); }

  LoadBlockedPeersRsp* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LoadBlockedPeersRsp* other);
  void UnsafeMergeFrom(const LoadBlockedPeersRsp& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // repeated .zproto.OutPeer peers = 1;
  int peers_size() const;
  void clear_peers();
  static const int kPeersFieldNumber = 1;
  const ::zproto::OutPeer& peers(int index) const;
  ::zproto::OutPeer* mutable_peers(int index);
  ::zproto::OutPeer* add_peers();
  ::google::protobuf::RepeatedPtrField< ::zproto::OutPeer >*
      mutable_peers();
  const ::google::protobuf::RepeatedPtrField< ::zproto::OutPeer >&
      peers() const;

  // @@protoc_insertion_point(class_scope:zproto.LoadBlockedPeersRsp)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::zproto::OutPeer > peers_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<LoadBlockedPeersRsp> LoadBlockedPeersRsp_default_instance_;

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

class LoadTopedPeersReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.LoadTopedPeersReq) */ {
 public:
  LoadTopedPeersReq();
  virtual ~LoadTopedPeersReq();

  LoadTopedPeersReq(const LoadTopedPeersReq& from);

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

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

  static const LoadTopedPeersReq* internal_default_instance();

  void Swap(LoadTopedPeersReq* other);

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

  inline LoadTopedPeersReq* New() const { return New(NULL); }

  LoadTopedPeersReq* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LoadTopedPeersReq* other);
  void UnsafeMergeFrom(const LoadTopedPeersReq& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // @@protoc_insertion_point(class_scope:zproto.LoadTopedPeersReq)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<LoadTopedPeersReq> LoadTopedPeersReq_default_instance_;

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

class LoadTopedPeersRsp : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.LoadTopedPeersRsp) */ {
 public:
  LoadTopedPeersRsp();
  virtual ~LoadTopedPeersRsp();

  LoadTopedPeersRsp(const LoadTopedPeersRsp& from);

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

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

  static const LoadTopedPeersRsp* internal_default_instance();

  void Swap(LoadTopedPeersRsp* other);

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

  inline LoadTopedPeersRsp* New() const { return New(NULL); }

  LoadTopedPeersRsp* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LoadTopedPeersRsp* other);
  void UnsafeMergeFrom(const LoadTopedPeersRsp& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // repeated .zproto.OutPeer peers = 1;
  int peers_size() const;
  void clear_peers();
  static const int kPeersFieldNumber = 1;
  const ::zproto::OutPeer& peers(int index) const;
  ::zproto::OutPeer* mutable_peers(int index);
  ::zproto::OutPeer* add_peers();
  ::google::protobuf::RepeatedPtrField< ::zproto::OutPeer >*
      mutable_peers();
  const ::google::protobuf::RepeatedPtrField< ::zproto::OutPeer >&
      peers() const;

  // @@protoc_insertion_point(class_scope:zproto.LoadTopedPeersRsp)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::zproto::OutPeer > peers_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<LoadTopedPeersRsp> LoadTopedPeersRsp_default_instance_;

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

class LoadDndedPeersReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.LoadDndedPeersReq) */ {
 public:
  LoadDndedPeersReq();
  virtual ~LoadDndedPeersReq();

  LoadDndedPeersReq(const LoadDndedPeersReq& from);

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

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

  static const LoadDndedPeersReq* internal_default_instance();

  void Swap(LoadDndedPeersReq* other);

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

  inline LoadDndedPeersReq* New() const { return New(NULL); }

  LoadDndedPeersReq* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LoadDndedPeersReq* other);
  void UnsafeMergeFrom(const LoadDndedPeersReq& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // @@protoc_insertion_point(class_scope:zproto.LoadDndedPeersReq)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<LoadDndedPeersReq> LoadDndedPeersReq_default_instance_;

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

class LoadDndedPeersRsp : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.LoadDndedPeersRsp) */ {
 public:
  LoadDndedPeersRsp();
  virtual ~LoadDndedPeersRsp();

  LoadDndedPeersRsp(const LoadDndedPeersRsp& from);

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

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

  static const LoadDndedPeersRsp* internal_default_instance();

  void Swap(LoadDndedPeersRsp* other);

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

  inline LoadDndedPeersRsp* New() const { return New(NULL); }

  LoadDndedPeersRsp* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LoadDndedPeersRsp* other);
  void UnsafeMergeFrom(const LoadDndedPeersRsp& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // repeated .zproto.OutPeer peers = 1;
  int peers_size() const;
  void clear_peers();
  static const int kPeersFieldNumber = 1;
  const ::zproto::OutPeer& peers(int index) const;
  ::zproto::OutPeer* mutable_peers(int index);
  ::zproto::OutPeer* add_peers();
  ::google::protobuf::RepeatedPtrField< ::zproto::OutPeer >*
      mutable_peers();
  const ::google::protobuf::RepeatedPtrField< ::zproto::OutPeer >&
      peers() const;

  // @@protoc_insertion_point(class_scope:zproto.LoadDndedPeersRsp)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedPtrField< ::zproto::OutPeer > peers_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<LoadDndedPeersRsp> LoadDndedPeersRsp_default_instance_;

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

class PeerBlockedNotify : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.PeerBlockedNotify) */ {
 public:
  PeerBlockedNotify();
  virtual ~PeerBlockedNotify();

  PeerBlockedNotify(const PeerBlockedNotify& from);

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

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

  static const PeerBlockedNotify* internal_default_instance();

  void Swap(PeerBlockedNotify* other);

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

  inline PeerBlockedNotify* New() const { return New(NULL); }

  PeerBlockedNotify* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PeerBlockedNotify* other);
  void UnsafeMergeFrom(const PeerBlockedNotify& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional .zproto.Peer peer = 1;
  bool has_peer() const;
  void clear_peer();
  static const int kPeerFieldNumber = 1;
  const ::zproto::Peer& peer() const;
  ::zproto::Peer* mutable_peer();
  ::zproto::Peer* release_peer();
  void set_allocated_peer(::zproto::Peer* peer);

  // @@protoc_insertion_point(class_scope:zproto.PeerBlockedNotify)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::zproto::Peer* peer_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<PeerBlockedNotify> PeerBlockedNotify_default_instance_;

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

class PeerUnblockedNotify : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.PeerUnblockedNotify) */ {
 public:
  PeerUnblockedNotify();
  virtual ~PeerUnblockedNotify();

  PeerUnblockedNotify(const PeerUnblockedNotify& from);

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

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

  static const PeerUnblockedNotify* internal_default_instance();

  void Swap(PeerUnblockedNotify* other);

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

  inline PeerUnblockedNotify* New() const { return New(NULL); }

  PeerUnblockedNotify* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PeerUnblockedNotify* other);
  void UnsafeMergeFrom(const PeerUnblockedNotify& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional .zproto.Peer peer = 1;
  bool has_peer() const;
  void clear_peer();
  static const int kPeerFieldNumber = 1;
  const ::zproto::Peer& peer() const;
  ::zproto::Peer* mutable_peer();
  ::zproto::Peer* release_peer();
  void set_allocated_peer(::zproto::Peer* peer);

  // @@protoc_insertion_point(class_scope:zproto.PeerUnblockedNotify)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::zproto::Peer* peer_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<PeerUnblockedNotify> PeerUnblockedNotify_default_instance_;

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

class PeerTopedNotify : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.PeerTopedNotify) */ {
 public:
  PeerTopedNotify();
  virtual ~PeerTopedNotify();

  PeerTopedNotify(const PeerTopedNotify& from);

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

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

  static const PeerTopedNotify* internal_default_instance();

  void Swap(PeerTopedNotify* other);

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

  inline PeerTopedNotify* New() const { return New(NULL); }

  PeerTopedNotify* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PeerTopedNotify* other);
  void UnsafeMergeFrom(const PeerTopedNotify& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional .zproto.Peer peer = 1;
  bool has_peer() const;
  void clear_peer();
  static const int kPeerFieldNumber = 1;
  const ::zproto::Peer& peer() const;
  ::zproto::Peer* mutable_peer();
  ::zproto::Peer* release_peer();
  void set_allocated_peer(::zproto::Peer* peer);

  // @@protoc_insertion_point(class_scope:zproto.PeerTopedNotify)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::zproto::Peer* peer_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<PeerTopedNotify> PeerTopedNotify_default_instance_;

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

class PeerUntopedNotify : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.PeerUntopedNotify) */ {
 public:
  PeerUntopedNotify();
  virtual ~PeerUntopedNotify();

  PeerUntopedNotify(const PeerUntopedNotify& from);

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

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

  static const PeerUntopedNotify* internal_default_instance();

  void Swap(PeerUntopedNotify* other);

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

  inline PeerUntopedNotify* New() const { return New(NULL); }

  PeerUntopedNotify* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PeerUntopedNotify* other);
  void UnsafeMergeFrom(const PeerUntopedNotify& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional .zproto.Peer peer = 1;
  bool has_peer() const;
  void clear_peer();
  static const int kPeerFieldNumber = 1;
  const ::zproto::Peer& peer() const;
  ::zproto::Peer* mutable_peer();
  ::zproto::Peer* release_peer();
  void set_allocated_peer(::zproto::Peer* peer);

  // @@protoc_insertion_point(class_scope:zproto.PeerUntopedNotify)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::zproto::Peer* peer_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<PeerUntopedNotify> PeerUntopedNotify_default_instance_;

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

class PeerDndedNotify : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.PeerDndedNotify) */ {
 public:
  PeerDndedNotify();
  virtual ~PeerDndedNotify();

  PeerDndedNotify(const PeerDndedNotify& from);

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

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

  static const PeerDndedNotify* internal_default_instance();

  void Swap(PeerDndedNotify* other);

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

  inline PeerDndedNotify* New() const { return New(NULL); }

  PeerDndedNotify* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PeerDndedNotify* other);
  void UnsafeMergeFrom(const PeerDndedNotify& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional .zproto.Peer peer = 1;
  bool has_peer() const;
  void clear_peer();
  static const int kPeerFieldNumber = 1;
  const ::zproto::Peer& peer() const;
  ::zproto::Peer* mutable_peer();
  ::zproto::Peer* release_peer();
  void set_allocated_peer(::zproto::Peer* peer);

  // @@protoc_insertion_point(class_scope:zproto.PeerDndedNotify)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::zproto::Peer* peer_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<PeerDndedNotify> PeerDndedNotify_default_instance_;

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

class PeerUndndedNotify : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:zproto.PeerUndndedNotify) */ {
 public:
  PeerUndndedNotify();
  virtual ~PeerUndndedNotify();

  PeerUndndedNotify(const PeerUndndedNotify& from);

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

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

  static const PeerUndndedNotify* internal_default_instance();

  void Swap(PeerUndndedNotify* other);

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

  inline PeerUndndedNotify* New() const { return New(NULL); }

  PeerUndndedNotify* New(::google::protobuf::Arena* arena) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PeerUndndedNotify* other);
  void UnsafeMergeFrom(const PeerUndndedNotify& from);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return _internal_metadata_.arena();
  }
  inline void* MaybeArenaPtr() const {
    return _internal_metadata_.raw_arena_ptr();
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const;

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

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

  // optional .zproto.Peer peer = 1;
  bool has_peer() const;
  void clear_peer();
  static const int kPeerFieldNumber = 1;
  const ::zproto::Peer& peer() const;
  ::zproto::Peer* mutable_peer();
  ::zproto::Peer* release_peer();
  void set_allocated_peer(::zproto::Peer* peer);

  // @@protoc_insertion_point(class_scope:zproto.PeerUndndedNotify)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::zproto::Peer* peer_;
  mutable int _cached_size_;
  friend void  protobuf_InitDefaults_dialogs_2eproto_impl();
  friend void  protobuf_AddDesc_dialogs_2eproto_impl();
  friend void protobuf_AssignDesc_dialogs_2eproto();
  friend void protobuf_ShutdownFile_dialogs_2eproto();

  void InitAsDefaultInstance();
};
extern ::google::protobuf::internal::ExplicitlyConstructed<PeerUndndedNotify> PeerUndndedNotify_default_instance_;

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


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

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
// Dialog

// optional .zproto.Peer peer = 1;
inline bool Dialog::has_peer() const {
  return this != internal_default_instance() && peer_ != NULL;
}
inline void Dialog::clear_peer() {
  if (GetArenaNoVirtual() == NULL && peer_ != NULL) delete peer_;
  peer_ = NULL;
}
inline const ::zproto::Peer& Dialog::peer() const {
  // @@protoc_insertion_point(field_get:zproto.Dialog.peer)
  return peer_ != NULL ? *peer_
                         : *::zproto::Peer::internal_default_instance();
}
inline ::zproto::Peer* Dialog::mutable_peer() {
  
  if (peer_ == NULL) {
    peer_ = new ::zproto::Peer;
  }
  // @@protoc_insertion_point(field_mutable:zproto.Dialog.peer)
  return peer_;
}
inline ::zproto::Peer* Dialog::release_peer() {
  // @@protoc_insertion_point(field_release:zproto.Dialog.peer)
  
  ::zproto::Peer* temp = peer_;
  peer_ = NULL;
  return temp;
}
inline void Dialog::set_allocated_peer(::zproto::Peer* peer) {
  delete peer_;
  peer_ = peer;
  if (peer) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:zproto.Dialog.peer)
}

// optional int32 unread_count = 2;
inline void Dialog::clear_unread_count() {
  unread_count_ = 0;
}
inline ::google::protobuf::int32 Dialog::unread_count() const {
  // @@protoc_insertion_point(field_get:zproto.Dialog.unread_count)
  return unread_count_;
}
inline void Dialog::set_unread_count(::google::protobuf::int32 value) {
  
  unread_count_ = value;
  // @@protoc_insertion_point(field_set:zproto.Dialog.unread_count)
}

// optional int64 sort_date = 3;
inline void Dialog::clear_sort_date() {
  sort_date_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 Dialog::sort_date() const {
  // @@protoc_insertion_point(field_get:zproto.Dialog.sort_date)
  return sort_date_;
}
inline void Dialog::set_sort_date(::google::protobuf::int64 value) {
  
  sort_date_ = value;
  // @@protoc_insertion_point(field_set:zproto.Dialog.sort_date)
}

// optional .zproto.MessageContainer last_message = 4;
inline bool Dialog::has_last_message() const {
  return this != internal_default_instance() && last_message_ != NULL;
}
inline void Dialog::clear_last_message() {
  if (GetArenaNoVirtual() == NULL && last_message_ != NULL) delete last_message_;
  last_message_ = NULL;
}
inline const ::zproto::MessageContainer& Dialog::last_message() const {
  // @@protoc_insertion_point(field_get:zproto.Dialog.last_message)
  return last_message_ != NULL ? *last_message_
                         : *::zproto::MessageContainer::internal_default_instance();
}
inline ::zproto::MessageContainer* Dialog::mutable_last_message() {
  
  if (last_message_ == NULL) {
    last_message_ = new ::zproto::MessageContainer;
  }
  // @@protoc_insertion_point(field_mutable:zproto.Dialog.last_message)
  return last_message_;
}
inline ::zproto::MessageContainer* Dialog::release_last_message() {
  // @@protoc_insertion_point(field_release:zproto.Dialog.last_message)
  
  ::zproto::MessageContainer* temp = last_message_;
  last_message_ = NULL;
  return temp;
}
inline void Dialog::set_allocated_last_message(::zproto::MessageContainer* last_message) {
  delete last_message_;
  last_message_ = last_message;
  if (last_message) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:zproto.Dialog.last_message)
}

// optional int64 first_unread_date = 5;
inline void Dialog::clear_first_unread_date() {
  first_unread_date_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 Dialog::first_unread_date() const {
  // @@protoc_insertion_point(field_get:zproto.Dialog.first_unread_date)
  return first_unread_date_;
}
inline void Dialog::set_first_unread_date(::google::protobuf::int64 value) {
  
  first_unread_date_ = value;
  // @@protoc_insertion_point(field_set:zproto.Dialog.first_unread_date)
}

inline const Dialog* Dialog::internal_default_instance() {
  return &Dialog_default_instance_.get();
}
// -------------------------------------------------------------------

// LoadDialogsReq

// optional int64 min_date = 1;
inline void LoadDialogsReq::clear_min_date() {
  min_date_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 LoadDialogsReq::min_date() const {
  // @@protoc_insertion_point(field_get:zproto.LoadDialogsReq.min_date)
  return min_date_;
}
inline void LoadDialogsReq::set_min_date(::google::protobuf::int64 value) {
  
  min_date_ = value;
  // @@protoc_insertion_point(field_set:zproto.LoadDialogsReq.min_date)
}

// optional .zproto.ListLoadMode load_mode = 2;
inline void LoadDialogsReq::clear_load_mode() {
  load_mode_ = 0;
}
inline ::zproto::ListLoadMode LoadDialogsReq::load_mode() const {
  // @@protoc_insertion_point(field_get:zproto.LoadDialogsReq.load_mode)
  return static_cast< ::zproto::ListLoadMode >(load_mode_);
}
inline void LoadDialogsReq::set_load_mode(::zproto::ListLoadMode value) {
  
  load_mode_ = value;
  // @@protoc_insertion_point(field_set:zproto.LoadDialogsReq.load_mode)
}

// optional int32 limit = 3;
inline void LoadDialogsReq::clear_limit() {
  limit_ = 0;
}
inline ::google::protobuf::int32 LoadDialogsReq::limit() const {
  // @@protoc_insertion_point(field_get:zproto.LoadDialogsReq.limit)
  return limit_;
}
inline void LoadDialogsReq::set_limit(::google::protobuf::int32 value) {
  
  limit_ = value;
  // @@protoc_insertion_point(field_set:zproto.LoadDialogsReq.limit)
}

inline const LoadDialogsReq* LoadDialogsReq::internal_default_instance() {
  return &LoadDialogsReq_default_instance_.get();
}
// -------------------------------------------------------------------

// LoadDialogsRsp

// repeated .zproto.Group groups = 1;
inline int LoadDialogsRsp::groups_size() const {
  return groups_.size();
}
inline void LoadDialogsRsp::clear_groups() {
  groups_.Clear();
}
inline const ::zproto::Group& LoadDialogsRsp::groups(int index) const {
  // @@protoc_insertion_point(field_get:zproto.LoadDialogsRsp.groups)
  return groups_.Get(index);
}
inline ::zproto::Group* LoadDialogsRsp::mutable_groups(int index) {
  // @@protoc_insertion_point(field_mutable:zproto.LoadDialogsRsp.groups)
  return groups_.Mutable(index);
}
inline ::zproto::Group* LoadDialogsRsp::add_groups() {
  // @@protoc_insertion_point(field_add:zproto.LoadDialogsRsp.groups)
  return groups_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::zproto::Group >*
LoadDialogsRsp::mutable_groups() {
  // @@protoc_insertion_point(field_mutable_list:zproto.LoadDialogsRsp.groups)
  return &groups_;
}
inline const ::google::protobuf::RepeatedPtrField< ::zproto::Group >&
LoadDialogsRsp::groups() const {
  // @@protoc_insertion_point(field_list:zproto.LoadDialogsRsp.groups)
  return groups_;
}

// repeated .zproto.User users = 2;
inline int LoadDialogsRsp::users_size() const {
  return users_.size();
}
inline void LoadDialogsRsp::clear_users() {
  users_.Clear();
}
inline const ::zproto::User& LoadDialogsRsp::users(int index) const {
  // @@protoc_insertion_point(field_get:zproto.LoadDialogsRsp.users)
  return users_.Get(index);
}
inline ::zproto::User* LoadDialogsRsp::mutable_users(int index) {
  // @@protoc_insertion_point(field_mutable:zproto.LoadDialogsRsp.users)
  return users_.Mutable(index);
}
inline ::zproto::User* LoadDialogsRsp::add_users() {
  // @@protoc_insertion_point(field_add:zproto.LoadDialogsRsp.users)
  return users_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::zproto::User >*
LoadDialogsRsp::mutable_users() {
  // @@protoc_insertion_point(field_mutable_list:zproto.LoadDialogsRsp.users)
  return &users_;
}
inline const ::google::protobuf::RepeatedPtrField< ::zproto::User >&
LoadDialogsRsp::users() const {
  // @@protoc_insertion_point(field_list:zproto.LoadDialogsRsp.users)
  return users_;
}

// repeated .zproto.Dialog dialogs = 3;
inline int LoadDialogsRsp::dialogs_size() const {
  return dialogs_.size();
}
inline void LoadDialogsRsp::clear_dialogs() {
  dialogs_.Clear();
}
inline const ::zproto::Dialog& LoadDialogsRsp::dialogs(int index) const {
  // @@protoc_insertion_point(field_get:zproto.LoadDialogsRsp.dialogs)
  return dialogs_.Get(index);
}
inline ::zproto::Dialog* LoadDialogsRsp::mutable_dialogs(int index) {
  // @@protoc_insertion_point(field_mutable:zproto.LoadDialogsRsp.dialogs)
  return dialogs_.Mutable(index);
}
inline ::zproto::Dialog* LoadDialogsRsp::add_dialogs() {
  // @@protoc_insertion_point(field_add:zproto.LoadDialogsRsp.dialogs)
  return dialogs_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::zproto::Dialog >*
LoadDialogsRsp::mutable_dialogs() {
  // @@protoc_insertion_point(field_mutable_list:zproto.LoadDialogsRsp.dialogs)
  return &dialogs_;
}
inline const ::google::protobuf::RepeatedPtrField< ::zproto::Dialog >&
LoadDialogsRsp::dialogs() const {
  // @@protoc_insertion_point(field_list:zproto.LoadDialogsRsp.dialogs)
  return dialogs_;
}

// repeated .zproto.UserOutPeer user_peers = 4;
inline int LoadDialogsRsp::user_peers_size() const {
  return user_peers_.size();
}
inline void LoadDialogsRsp::clear_user_peers() {
  user_peers_.Clear();
}
inline const ::zproto::UserOutPeer& LoadDialogsRsp::user_peers(int index) const {
  // @@protoc_insertion_point(field_get:zproto.LoadDialogsRsp.user_peers)
  return user_peers_.Get(index);
}
inline ::zproto::UserOutPeer* LoadDialogsRsp::mutable_user_peers(int index) {
  // @@protoc_insertion_point(field_mutable:zproto.LoadDialogsRsp.user_peers)
  return user_peers_.Mutable(index);
}
inline ::zproto::UserOutPeer* LoadDialogsRsp::add_user_peers() {
  // @@protoc_insertion_point(field_add:zproto.LoadDialogsRsp.user_peers)
  return user_peers_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::zproto::UserOutPeer >*
LoadDialogsRsp::mutable_user_peers() {
  // @@protoc_insertion_point(field_mutable_list:zproto.LoadDialogsRsp.user_peers)
  return &user_peers_;
}
inline const ::google::protobuf::RepeatedPtrField< ::zproto::UserOutPeer >&
LoadDialogsRsp::user_peers() const {
  // @@protoc_insertion_point(field_list:zproto.LoadDialogsRsp.user_peers)
  return user_peers_;
}

// repeated .zproto.GroupOutPeer group_peers = 5;
inline int LoadDialogsRsp::group_peers_size() const {
  return group_peers_.size();
}
inline void LoadDialogsRsp::clear_group_peers() {
  group_peers_.Clear();
}
inline const ::zproto::GroupOutPeer& LoadDialogsRsp::group_peers(int index) const {
  // @@protoc_insertion_point(field_get:zproto.LoadDialogsRsp.group_peers)
  return group_peers_.Get(index);
}
inline ::zproto::GroupOutPeer* LoadDialogsRsp::mutable_group_peers(int index) {
  // @@protoc_insertion_point(field_mutable:zproto.LoadDialogsRsp.group_peers)
  return group_peers_.Mutable(index);
}
inline ::zproto::GroupOutPeer* LoadDialogsRsp::add_group_peers() {
  // @@protoc_insertion_point(field_add:zproto.LoadDialogsRsp.group_peers)
  return group_peers_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::zproto::GroupOutPeer >*
LoadDialogsRsp::mutable_group_peers() {
  // @@protoc_insertion_point(field_mutable_list:zproto.LoadDialogsRsp.group_peers)
  return &group_peers_;
}
inline const ::google::protobuf::RepeatedPtrField< ::zproto::GroupOutPeer >&
LoadDialogsRsp::group_peers() const {
  // @@protoc_insertion_point(field_list:zproto.LoadDialogsRsp.group_peers)
  return group_peers_;
}

inline const LoadDialogsRsp* LoadDialogsRsp::internal_default_instance() {
  return &LoadDialogsRsp_default_instance_.get();
}
// -------------------------------------------------------------------

// CreateChatDialogReq

// optional string peer_id = 1;
inline void CreateChatDialogReq::clear_peer_id() {
  peer_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& CreateChatDialogReq::peer_id() const {
  // @@protoc_insertion_point(field_get:zproto.CreateChatDialogReq.peer_id)
  return peer_id_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CreateChatDialogReq::set_peer_id(const ::std::string& value) {
  
  peer_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:zproto.CreateChatDialogReq.peer_id)
}
inline void CreateChatDialogReq::set_peer_id(const char* value) {
  
  peer_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:zproto.CreateChatDialogReq.peer_id)
}
inline void CreateChatDialogReq::set_peer_id(const char* value, size_t size) {
  
  peer_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:zproto.CreateChatDialogReq.peer_id)
}
inline ::std::string* CreateChatDialogReq::mutable_peer_id() {
  
  // @@protoc_insertion_point(field_mutable:zproto.CreateChatDialogReq.peer_id)
  return peer_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* CreateChatDialogReq::release_peer_id() {
  // @@protoc_insertion_point(field_release:zproto.CreateChatDialogReq.peer_id)
  
  return peer_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void CreateChatDialogReq::set_allocated_peer_id(::std::string* peer_id) {
  if (peer_id != NULL) {
    
  } else {
    
  }
  peer_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), peer_id);
  // @@protoc_insertion_point(field_set_allocated:zproto.CreateChatDialogReq.peer_id)
}

inline const CreateChatDialogReq* CreateChatDialogReq::internal_default_instance() {
  return &CreateChatDialogReq_default_instance_.get();
}
// -------------------------------------------------------------------

// CreateChatDialogRsp

// optional .zproto.OutPeer peer = 1;
inline bool CreateChatDialogRsp::has_peer() const {
  return this != internal_default_instance() && peer_ != NULL;
}
inline void CreateChatDialogRsp::clear_peer() {
  if (GetArenaNoVirtual() == NULL && peer_ != NULL) delete peer_;
  peer_ = NULL;
}
inline const ::zproto::OutPeer& CreateChatDialogRsp::peer() const {
  // @@protoc_insertion_point(field_get:zproto.CreateChatDialogRsp.peer)
  return peer_ != NULL ? *peer_
                         : *::zproto::OutPeer::internal_default_instance();
}
inline ::zproto::OutPeer* CreateChatDialogRsp::mutable_peer() {
  
  if (peer_ == NULL) {
    peer_ = new ::zproto::OutPeer;
  }
  // @@protoc_insertion_point(field_mutable:zproto.CreateChatDialogRsp.peer)
  return peer_;
}
inline ::zproto::OutPeer* CreateChatDialogRsp::release_peer() {
  // @@protoc_insertion_point(field_release:zproto.CreateChatDialogRsp.peer)
  
  ::zproto::OutPeer* temp = peer_;
  peer_ = NULL;
  return temp;
}
inline void CreateChatDialogRsp::set_allocated_peer(::zproto::OutPeer* peer) {
  delete peer_;
  peer_ = peer;
  if (peer) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:zproto.CreateChatDialogRsp.peer)
}

inline const CreateChatDialogRsp* CreateChatDialogRsp::internal_default_instance() {
  return &CreateChatDialogRsp_default_instance_.get();
}
// -------------------------------------------------------------------

// BlockPeerReq

// optional .zproto.OutPeer peer = 1;
inline bool BlockPeerReq::has_peer() const {
  return this != internal_default_instance() && peer_ != NULL;
}
inline void BlockPeerReq::clear_peer() {
  if (GetArenaNoVirtual() == NULL && peer_ != NULL) delete peer_;
  peer_ = NULL;
}
inline const ::zproto::OutPeer& BlockPeerReq::peer() const {
  // @@protoc_insertion_point(field_get:zproto.BlockPeerReq.peer)
  return peer_ != NULL ? *peer_
                         : *::zproto::OutPeer::internal_default_instance();
}
inline ::zproto::OutPeer* BlockPeerReq::mutable_peer() {
  
  if (peer_ == NULL) {
    peer_ = new ::zproto::OutPeer;
  }
  // @@protoc_insertion_point(field_mutable:zproto.BlockPeerReq.peer)
  return peer_;
}
inline ::zproto::OutPeer* BlockPeerReq::release_peer() {
  // @@protoc_insertion_point(field_release:zproto.BlockPeerReq.peer)
  
  ::zproto::OutPeer* temp = peer_;
  peer_ = NULL;
  return temp;
}
inline void BlockPeerReq::set_allocated_peer(::zproto::OutPeer* peer) {
  delete peer_;
  peer_ = peer;
  if (peer) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:zproto.BlockPeerReq.peer)
}

inline const BlockPeerReq* BlockPeerReq::internal_default_instance() {
  return &BlockPeerReq_default_instance_.get();
}
// -------------------------------------------------------------------

// UnblockPeerReq

// optional .zproto.OutPeer peer = 1;
inline bool UnblockPeerReq::has_peer() const {
  return this != internal_default_instance() && peer_ != NULL;
}
inline void UnblockPeerReq::clear_peer() {
  if (GetArenaNoVirtual() == NULL && peer_ != NULL) delete peer_;
  peer_ = NULL;
}
inline const ::zproto::OutPeer& UnblockPeerReq::peer() const {
  // @@protoc_insertion_point(field_get:zproto.UnblockPeerReq.peer)
  return peer_ != NULL ? *peer_
                         : *::zproto::OutPeer::internal_default_instance();
}
inline ::zproto::OutPeer* UnblockPeerReq::mutable_peer() {
  
  if (peer_ == NULL) {
    peer_ = new ::zproto::OutPeer;
  }
  // @@protoc_insertion_point(field_mutable:zproto.UnblockPeerReq.peer)
  return peer_;
}
inline ::zproto::OutPeer* UnblockPeerReq::release_peer() {
  // @@protoc_insertion_point(field_release:zproto.UnblockPeerReq.peer)
  
  ::zproto::OutPeer* temp = peer_;
  peer_ = NULL;
  return temp;
}
inline void UnblockPeerReq::set_allocated_peer(::zproto::OutPeer* peer) {
  delete peer_;
  peer_ = peer;
  if (peer) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:zproto.UnblockPeerReq.peer)
}

inline const UnblockPeerReq* UnblockPeerReq::internal_default_instance() {
  return &UnblockPeerReq_default_instance_.get();
}
// -------------------------------------------------------------------

// TopPeerReq

// optional .zproto.OutPeer peer = 1;
inline bool TopPeerReq::has_peer() const {
  return this != internal_default_instance() && peer_ != NULL;
}
inline void TopPeerReq::clear_peer() {
  if (GetArenaNoVirtual() == NULL && peer_ != NULL) delete peer_;
  peer_ = NULL;
}
inline const ::zproto::OutPeer& TopPeerReq::peer() const {
  // @@protoc_insertion_point(field_get:zproto.TopPeerReq.peer)
  return peer_ != NULL ? *peer_
                         : *::zproto::OutPeer::internal_default_instance();
}
inline ::zproto::OutPeer* TopPeerReq::mutable_peer() {
  
  if (peer_ == NULL) {
    peer_ = new ::zproto::OutPeer;
  }
  // @@protoc_insertion_point(field_mutable:zproto.TopPeerReq.peer)
  return peer_;
}
inline ::zproto::OutPeer* TopPeerReq::release_peer() {
  // @@protoc_insertion_point(field_release:zproto.TopPeerReq.peer)
  
  ::zproto::OutPeer* temp = peer_;
  peer_ = NULL;
  return temp;
}
inline void TopPeerReq::set_allocated_peer(::zproto::OutPeer* peer) {
  delete peer_;
  peer_ = peer;
  if (peer) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:zproto.TopPeerReq.peer)
}

inline const TopPeerReq* TopPeerReq::internal_default_instance() {
  return &TopPeerReq_default_instance_.get();
}
// -------------------------------------------------------------------

// UntopPeerReq

// optional .zproto.OutPeer peer = 1;
inline bool UntopPeerReq::has_peer() const {
  return this != internal_default_instance() && peer_ != NULL;
}
inline void UntopPeerReq::clear_peer() {
  if (GetArenaNoVirtual() == NULL && peer_ != NULL) delete peer_;
  peer_ = NULL;
}
inline const ::zproto::OutPeer& UntopPeerReq::peer() const {
  // @@protoc_insertion_point(field_get:zproto.UntopPeerReq.peer)
  return peer_ != NULL ? *peer_
                         : *::zproto::OutPeer::internal_default_instance();
}
inline ::zproto::OutPeer* UntopPeerReq::mutable_peer() {
  
  if (peer_ == NULL) {
    peer_ = new ::zproto::OutPeer;
  }
  // @@protoc_insertion_point(field_mutable:zproto.UntopPeerReq.peer)
  return peer_;
}
inline ::zproto::OutPeer* UntopPeerReq::release_peer() {
  // @@protoc_insertion_point(field_release:zproto.UntopPeerReq.peer)
  
  ::zproto::OutPeer* temp = peer_;
  peer_ = NULL;
  return temp;
}
inline void UntopPeerReq::set_allocated_peer(::zproto::OutPeer* peer) {
  delete peer_;
  peer_ = peer;
  if (peer) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:zproto.UntopPeerReq.peer)
}

inline const UntopPeerReq* UntopPeerReq::internal_default_instance() {
  return &UntopPeerReq_default_instance_.get();
}
// -------------------------------------------------------------------

// DndPeerReq

// optional .zproto.OutPeer peer = 1;
inline bool DndPeerReq::has_peer() const {
  return this != internal_default_instance() && peer_ != NULL;
}
inline void DndPeerReq::clear_peer() {
  if (GetArenaNoVirtual() == NULL && peer_ != NULL) delete peer_;
  peer_ = NULL;
}
inline const ::zproto::OutPeer& DndPeerReq::peer() const {
  // @@protoc_insertion_point(field_get:zproto.DndPeerReq.peer)
  return peer_ != NULL ? *peer_
                         : *::zproto::OutPeer::internal_default_instance();
}
inline ::zproto::OutPeer* DndPeerReq::mutable_peer() {
  
  if (peer_ == NULL) {
    peer_ = new ::zproto::OutPeer;
  }
  // @@protoc_insertion_point(field_mutable:zproto.DndPeerReq.peer)
  return peer_;
}
inline ::zproto::OutPeer* DndPeerReq::release_peer() {
  // @@protoc_insertion_point(field_release:zproto.DndPeerReq.peer)
  
  ::zproto::OutPeer* temp = peer_;
  peer_ = NULL;
  return temp;
}
inline void DndPeerReq::set_allocated_peer(::zproto::OutPeer* peer) {
  delete peer_;
  peer_ = peer;
  if (peer) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:zproto.DndPeerReq.peer)
}

inline const DndPeerReq* DndPeerReq::internal_default_instance() {
  return &DndPeerReq_default_instance_.get();
}
// -------------------------------------------------------------------

// UndndPeerReq

// optional .zproto.OutPeer peer = 1;
inline bool UndndPeerReq::has_peer() const {
  return this != internal_default_instance() && peer_ != NULL;
}
inline void UndndPeerReq::clear_peer() {
  if (GetArenaNoVirtual() == NULL && peer_ != NULL) delete peer_;
  peer_ = NULL;
}
inline const ::zproto::OutPeer& UndndPeerReq::peer() const {
  // @@protoc_insertion_point(field_get:zproto.UndndPeerReq.peer)
  return peer_ != NULL ? *peer_
                         : *::zproto::OutPeer::internal_default_instance();
}
inline ::zproto::OutPeer* UndndPeerReq::mutable_peer() {
  
  if (peer_ == NULL) {
    peer_ = new ::zproto::OutPeer;
  }
  // @@protoc_insertion_point(field_mutable:zproto.UndndPeerReq.peer)
  return peer_;
}
inline ::zproto::OutPeer* UndndPeerReq::release_peer() {
  // @@protoc_insertion_point(field_release:zproto.UndndPeerReq.peer)
  
  ::zproto::OutPeer* temp = peer_;
  peer_ = NULL;
  return temp;
}
inline void UndndPeerReq::set_allocated_peer(::zproto::OutPeer* peer) {
  delete peer_;
  peer_ = peer;
  if (peer) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:zproto.UndndPeerReq.peer)
}

inline const UndndPeerReq* UndndPeerReq::internal_default_instance() {
  return &UndndPeerReq_default_instance_.get();
}
// -------------------------------------------------------------------

// LoadBlockedPeersReq

inline const LoadBlockedPeersReq* LoadBlockedPeersReq::internal_default_instance() {
  return &LoadBlockedPeersReq_default_instance_.get();
}
// -------------------------------------------------------------------

// LoadBlockedPeersRsp

// repeated .zproto.OutPeer peers = 1;
inline int LoadBlockedPeersRsp::peers_size() const {
  return peers_.size();
}
inline void LoadBlockedPeersRsp::clear_peers() {
  peers_.Clear();
}
inline const ::zproto::OutPeer& LoadBlockedPeersRsp::peers(int index) const {
  // @@protoc_insertion_point(field_get:zproto.LoadBlockedPeersRsp.peers)
  return peers_.Get(index);
}
inline ::zproto::OutPeer* LoadBlockedPeersRsp::mutable_peers(int index) {
  // @@protoc_insertion_point(field_mutable:zproto.LoadBlockedPeersRsp.peers)
  return peers_.Mutable(index);
}
inline ::zproto::OutPeer* LoadBlockedPeersRsp::add_peers() {
  // @@protoc_insertion_point(field_add:zproto.LoadBlockedPeersRsp.peers)
  return peers_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::zproto::OutPeer >*
LoadBlockedPeersRsp::mutable_peers() {
  // @@protoc_insertion_point(field_mutable_list:zproto.LoadBlockedPeersRsp.peers)
  return &peers_;
}
inline const ::google::protobuf::RepeatedPtrField< ::zproto::OutPeer >&
LoadBlockedPeersRsp::peers() const {
  // @@protoc_insertion_point(field_list:zproto.LoadBlockedPeersRsp.peers)
  return peers_;
}

inline const LoadBlockedPeersRsp* LoadBlockedPeersRsp::internal_default_instance() {
  return &LoadBlockedPeersRsp_default_instance_.get();
}
// -------------------------------------------------------------------

// LoadTopedPeersReq

inline const LoadTopedPeersReq* LoadTopedPeersReq::internal_default_instance() {
  return &LoadTopedPeersReq_default_instance_.get();
}
// -------------------------------------------------------------------

// LoadTopedPeersRsp

// repeated .zproto.OutPeer peers = 1;
inline int LoadTopedPeersRsp::peers_size() const {
  return peers_.size();
}
inline void LoadTopedPeersRsp::clear_peers() {
  peers_.Clear();
}
inline const ::zproto::OutPeer& LoadTopedPeersRsp::peers(int index) const {
  // @@protoc_insertion_point(field_get:zproto.LoadTopedPeersRsp.peers)
  return peers_.Get(index);
}
inline ::zproto::OutPeer* LoadTopedPeersRsp::mutable_peers(int index) {
  // @@protoc_insertion_point(field_mutable:zproto.LoadTopedPeersRsp.peers)
  return peers_.Mutable(index);
}
inline ::zproto::OutPeer* LoadTopedPeersRsp::add_peers() {
  // @@protoc_insertion_point(field_add:zproto.LoadTopedPeersRsp.peers)
  return peers_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::zproto::OutPeer >*
LoadTopedPeersRsp::mutable_peers() {
  // @@protoc_insertion_point(field_mutable_list:zproto.LoadTopedPeersRsp.peers)
  return &peers_;
}
inline const ::google::protobuf::RepeatedPtrField< ::zproto::OutPeer >&
LoadTopedPeersRsp::peers() const {
  // @@protoc_insertion_point(field_list:zproto.LoadTopedPeersRsp.peers)
  return peers_;
}

inline const LoadTopedPeersRsp* LoadTopedPeersRsp::internal_default_instance() {
  return &LoadTopedPeersRsp_default_instance_.get();
}
// -------------------------------------------------------------------

// LoadDndedPeersReq

inline const LoadDndedPeersReq* LoadDndedPeersReq::internal_default_instance() {
  return &LoadDndedPeersReq_default_instance_.get();
}
// -------------------------------------------------------------------

// LoadDndedPeersRsp

// repeated .zproto.OutPeer peers = 1;
inline int LoadDndedPeersRsp::peers_size() const {
  return peers_.size();
}
inline void LoadDndedPeersRsp::clear_peers() {
  peers_.Clear();
}
inline const ::zproto::OutPeer& LoadDndedPeersRsp::peers(int index) const {
  // @@protoc_insertion_point(field_get:zproto.LoadDndedPeersRsp.peers)
  return peers_.Get(index);
}
inline ::zproto::OutPeer* LoadDndedPeersRsp::mutable_peers(int index) {
  // @@protoc_insertion_point(field_mutable:zproto.LoadDndedPeersRsp.peers)
  return peers_.Mutable(index);
}
inline ::zproto::OutPeer* LoadDndedPeersRsp::add_peers() {
  // @@protoc_insertion_point(field_add:zproto.LoadDndedPeersRsp.peers)
  return peers_.Add();
}
inline ::google::protobuf::RepeatedPtrField< ::zproto::OutPeer >*
LoadDndedPeersRsp::mutable_peers() {
  // @@protoc_insertion_point(field_mutable_list:zproto.LoadDndedPeersRsp.peers)
  return &peers_;
}
inline const ::google::protobuf::RepeatedPtrField< ::zproto::OutPeer >&
LoadDndedPeersRsp::peers() const {
  // @@protoc_insertion_point(field_list:zproto.LoadDndedPeersRsp.peers)
  return peers_;
}

inline const LoadDndedPeersRsp* LoadDndedPeersRsp::internal_default_instance() {
  return &LoadDndedPeersRsp_default_instance_.get();
}
// -------------------------------------------------------------------

// PeerBlockedNotify

// optional .zproto.Peer peer = 1;
inline bool PeerBlockedNotify::has_peer() const {
  return this != internal_default_instance() && peer_ != NULL;
}
inline void PeerBlockedNotify::clear_peer() {
  if (GetArenaNoVirtual() == NULL && peer_ != NULL) delete peer_;
  peer_ = NULL;
}
inline const ::zproto::Peer& PeerBlockedNotify::peer() const {
  // @@protoc_insertion_point(field_get:zproto.PeerBlockedNotify.peer)
  return peer_ != NULL ? *peer_
                         : *::zproto::Peer::internal_default_instance();
}
inline ::zproto::Peer* PeerBlockedNotify::mutable_peer() {
  
  if (peer_ == NULL) {
    peer_ = new ::zproto::Peer;
  }
  // @@protoc_insertion_point(field_mutable:zproto.PeerBlockedNotify.peer)
  return peer_;
}
inline ::zproto::Peer* PeerBlockedNotify::release_peer() {
  // @@protoc_insertion_point(field_release:zproto.PeerBlockedNotify.peer)
  
  ::zproto::Peer* temp = peer_;
  peer_ = NULL;
  return temp;
}
inline void PeerBlockedNotify::set_allocated_peer(::zproto::Peer* peer) {
  delete peer_;
  peer_ = peer;
  if (peer) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:zproto.PeerBlockedNotify.peer)
}

inline const PeerBlockedNotify* PeerBlockedNotify::internal_default_instance() {
  return &PeerBlockedNotify_default_instance_.get();
}
// -------------------------------------------------------------------

// PeerUnblockedNotify

// optional .zproto.Peer peer = 1;
inline bool PeerUnblockedNotify::has_peer() const {
  return this != internal_default_instance() && peer_ != NULL;
}
inline void PeerUnblockedNotify::clear_peer() {
  if (GetArenaNoVirtual() == NULL && peer_ != NULL) delete peer_;
  peer_ = NULL;
}
inline const ::zproto::Peer& PeerUnblockedNotify::peer() const {
  // @@protoc_insertion_point(field_get:zproto.PeerUnblockedNotify.peer)
  return peer_ != NULL ? *peer_
                         : *::zproto::Peer::internal_default_instance();
}
inline ::zproto::Peer* PeerUnblockedNotify::mutable_peer() {
  
  if (peer_ == NULL) {
    peer_ = new ::zproto::Peer;
  }
  // @@protoc_insertion_point(field_mutable:zproto.PeerUnblockedNotify.peer)
  return peer_;
}
inline ::zproto::Peer* PeerUnblockedNotify::release_peer() {
  // @@protoc_insertion_point(field_release:zproto.PeerUnblockedNotify.peer)
  
  ::zproto::Peer* temp = peer_;
  peer_ = NULL;
  return temp;
}
inline void PeerUnblockedNotify::set_allocated_peer(::zproto::Peer* peer) {
  delete peer_;
  peer_ = peer;
  if (peer) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:zproto.PeerUnblockedNotify.peer)
}

inline const PeerUnblockedNotify* PeerUnblockedNotify::internal_default_instance() {
  return &PeerUnblockedNotify_default_instance_.get();
}
// -------------------------------------------------------------------

// PeerTopedNotify

// optional .zproto.Peer peer = 1;
inline bool PeerTopedNotify::has_peer() const {
  return this != internal_default_instance() && peer_ != NULL;
}
inline void PeerTopedNotify::clear_peer() {
  if (GetArenaNoVirtual() == NULL && peer_ != NULL) delete peer_;
  peer_ = NULL;
}
inline const ::zproto::Peer& PeerTopedNotify::peer() const {
  // @@protoc_insertion_point(field_get:zproto.PeerTopedNotify.peer)
  return peer_ != NULL ? *peer_
                         : *::zproto::Peer::internal_default_instance();
}
inline ::zproto::Peer* PeerTopedNotify::mutable_peer() {
  
  if (peer_ == NULL) {
    peer_ = new ::zproto::Peer;
  }
  // @@protoc_insertion_point(field_mutable:zproto.PeerTopedNotify.peer)
  return peer_;
}
inline ::zproto::Peer* PeerTopedNotify::release_peer() {
  // @@protoc_insertion_point(field_release:zproto.PeerTopedNotify.peer)
  
  ::zproto::Peer* temp = peer_;
  peer_ = NULL;
  return temp;
}
inline void PeerTopedNotify::set_allocated_peer(::zproto::Peer* peer) {
  delete peer_;
  peer_ = peer;
  if (peer) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:zproto.PeerTopedNotify.peer)
}

inline const PeerTopedNotify* PeerTopedNotify::internal_default_instance() {
  return &PeerTopedNotify_default_instance_.get();
}
// -------------------------------------------------------------------

// PeerUntopedNotify

// optional .zproto.Peer peer = 1;
inline bool PeerUntopedNotify::has_peer() const {
  return this != internal_default_instance() && peer_ != NULL;
}
inline void PeerUntopedNotify::clear_peer() {
  if (GetArenaNoVirtual() == NULL && peer_ != NULL) delete peer_;
  peer_ = NULL;
}
inline const ::zproto::Peer& PeerUntopedNotify::peer() const {
  // @@protoc_insertion_point(field_get:zproto.PeerUntopedNotify.peer)
  return peer_ != NULL ? *peer_
                         : *::zproto::Peer::internal_default_instance();
}
inline ::zproto::Peer* PeerUntopedNotify::mutable_peer() {
  
  if (peer_ == NULL) {
    peer_ = new ::zproto::Peer;
  }
  // @@protoc_insertion_point(field_mutable:zproto.PeerUntopedNotify.peer)
  return peer_;
}
inline ::zproto::Peer* PeerUntopedNotify::release_peer() {
  // @@protoc_insertion_point(field_release:zproto.PeerUntopedNotify.peer)
  
  ::zproto::Peer* temp = peer_;
  peer_ = NULL;
  return temp;
}
inline void PeerUntopedNotify::set_allocated_peer(::zproto::Peer* peer) {
  delete peer_;
  peer_ = peer;
  if (peer) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:zproto.PeerUntopedNotify.peer)
}

inline const PeerUntopedNotify* PeerUntopedNotify::internal_default_instance() {
  return &PeerUntopedNotify_default_instance_.get();
}
// -------------------------------------------------------------------

// PeerDndedNotify

// optional .zproto.Peer peer = 1;
inline bool PeerDndedNotify::has_peer() const {
  return this != internal_default_instance() && peer_ != NULL;
}
inline void PeerDndedNotify::clear_peer() {
  if (GetArenaNoVirtual() == NULL && peer_ != NULL) delete peer_;
  peer_ = NULL;
}
inline const ::zproto::Peer& PeerDndedNotify::peer() const {
  // @@protoc_insertion_point(field_get:zproto.PeerDndedNotify.peer)
  return peer_ != NULL ? *peer_
                         : *::zproto::Peer::internal_default_instance();
}
inline ::zproto::Peer* PeerDndedNotify::mutable_peer() {
  
  if (peer_ == NULL) {
    peer_ = new ::zproto::Peer;
  }
  // @@protoc_insertion_point(field_mutable:zproto.PeerDndedNotify.peer)
  return peer_;
}
inline ::zproto::Peer* PeerDndedNotify::release_peer() {
  // @@protoc_insertion_point(field_release:zproto.PeerDndedNotify.peer)
  
  ::zproto::Peer* temp = peer_;
  peer_ = NULL;
  return temp;
}
inline void PeerDndedNotify::set_allocated_peer(::zproto::Peer* peer) {
  delete peer_;
  peer_ = peer;
  if (peer) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:zproto.PeerDndedNotify.peer)
}

inline const PeerDndedNotify* PeerDndedNotify::internal_default_instance() {
  return &PeerDndedNotify_default_instance_.get();
}
// -------------------------------------------------------------------

// PeerUndndedNotify

// optional .zproto.Peer peer = 1;
inline bool PeerUndndedNotify::has_peer() const {
  return this != internal_default_instance() && peer_ != NULL;
}
inline void PeerUndndedNotify::clear_peer() {
  if (GetArenaNoVirtual() == NULL && peer_ != NULL) delete peer_;
  peer_ = NULL;
}
inline const ::zproto::Peer& PeerUndndedNotify::peer() const {
  // @@protoc_insertion_point(field_get:zproto.PeerUndndedNotify.peer)
  return peer_ != NULL ? *peer_
                         : *::zproto::Peer::internal_default_instance();
}
inline ::zproto::Peer* PeerUndndedNotify::mutable_peer() {
  
  if (peer_ == NULL) {
    peer_ = new ::zproto::Peer;
  }
  // @@protoc_insertion_point(field_mutable:zproto.PeerUndndedNotify.peer)
  return peer_;
}
inline ::zproto::Peer* PeerUndndedNotify::release_peer() {
  // @@protoc_insertion_point(field_release:zproto.PeerUndndedNotify.peer)
  
  ::zproto::Peer* temp = peer_;
  peer_ = NULL;
  return temp;
}
inline void PeerUndndedNotify::set_allocated_peer(::zproto::Peer* peer) {
  delete peer_;
  peer_ = peer;
  if (peer) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:zproto.PeerUndndedNotify.peer)
}

inline const PeerUndndedNotify* PeerUndndedNotify::internal_default_instance() {
  return &PeerUndndedNotify_default_instance_.get();
}
#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace zproto

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_dialogs_2eproto__INCLUDED
