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

#ifndef PROTOBUF_HekateClientProto_2eproto__INCLUDED
#define PROTOBUF_HekateClientProto_2eproto__INCLUDED

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 3000000
#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 3000000 < 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/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "Protobuf/Proto/Server/HekateServerProto.pb.h"
// @@protoc_insertion_point(includes)

namespace Hekate {
namespace Protobuf {
namespace Proto {
namespace Client {

// Internal implementation detail -- do not call these.
void protobuf_AddDesc_HekateClientProto_2eproto();
void protobuf_AssignDesc_HekateClientProto_2eproto();
void protobuf_ShutdownFile_HekateClientProto_2eproto();

class AddHookMessage;
class RemoveHookMessage;
class ByteFilterMessage;
class SubstringFilterMessage;
class LengthFilterMessage;
class SubstituteMessage;
class ReplacementMessage;
class AddFilterMessage;
class RemoveFilterMessage;
class ReplayMessage;
class ClientToHekateMessage;
class HekateClientMessage;

enum FilterType {
  BYTE = 0,
  LENGTH = 1,
  SUBSTRING = 2
};
bool FilterType_IsValid(int value);
const FilterType FilterType_MIN = BYTE;
const FilterType FilterType_MAX = SUBSTRING;
const int FilterType_ARRAYSIZE = FilterType_MAX + 1;

const ::google::protobuf::EnumDescriptor* FilterType_descriptor();
inline const ::std::string& FilterType_Name(FilterType value) {
  return ::google::protobuf::internal::NameOfEnum(
    FilterType_descriptor(), value);
}
inline bool FilterType_Parse(
    const ::std::string& name, FilterType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<FilterType>(
    FilterType_descriptor(), name, value);
}
enum LengthType {
  LESS = 0,
  EQUAL = 1,
  GREATER = 2
};
bool LengthType_IsValid(int value);
const LengthType LengthType_MIN = LESS;
const LengthType LengthType_MAX = GREATER;
const int LengthType_ARRAYSIZE = LengthType_MAX + 1;

const ::google::protobuf::EnumDescriptor* LengthType_descriptor();
inline const ::std::string& LengthType_Name(LengthType value) {
  return ::google::protobuf::internal::NameOfEnum(
    LengthType_descriptor(), value);
}
inline bool LengthType_Parse(
    const ::std::string& name, LengthType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<LengthType>(
    LengthType_descriptor(), name, value);
}
enum MessageType {
  ADD_HOOK = 0,
  REMOVE_HOOK = 1,
  ADD_FILTER = 2,
  REMOVE_FILTER = 3,
  PAUSE = 4,
  CONTINUE = 5,
  REPLAY = 6
};
bool MessageType_IsValid(int value);
const MessageType MessageType_MIN = ADD_HOOK;
const MessageType MessageType_MAX = REPLAY;
const int MessageType_ARRAYSIZE = MessageType_MAX + 1;

const ::google::protobuf::EnumDescriptor* MessageType_descriptor();
inline const ::std::string& MessageType_Name(MessageType value) {
  return ::google::protobuf::internal::NameOfEnum(
    MessageType_descriptor(), value);
}
inline bool MessageType_Parse(
    const ::std::string& name, MessageType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<MessageType>(
    MessageType_descriptor(), name, value);
}
// ===================================================================

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

  AddHookMessage(const AddHookMessage& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(AddHookMessage* other);

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

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

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

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(AddHookMessage* other);
  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 -------------------------------------------------------

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

  // @@protoc_insertion_point(class_scope:Hekate.Protobuf.Proto.Client.AddHookMessage)
 private:
  inline void set_has_name();
  inline void clear_has_name();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  friend void  protobuf_AddDesc_HekateClientProto_2eproto();
  friend void protobuf_AssignDesc_HekateClientProto_2eproto();
  friend void protobuf_ShutdownFile_HekateClientProto_2eproto();

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

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

  RemoveHookMessage(const RemoveHookMessage& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(RemoveHookMessage* other);

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

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

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

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RemoveHookMessage* other);
  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 -------------------------------------------------------

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

  // @@protoc_insertion_point(class_scope:Hekate.Protobuf.Proto.Client.RemoveHookMessage)
 private:
  inline void set_has_name();
  inline void clear_has_name();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  friend void  protobuf_AddDesc_HekateClientProto_2eproto();
  friend void protobuf_AssignDesc_HekateClientProto_2eproto();
  friend void protobuf_ShutdownFile_HekateClientProto_2eproto();

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

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

  ByteFilterMessage(const ByteFilterMessage& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(ByteFilterMessage* other);

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

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

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

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ByteFilterMessage* other);
  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 int32 byte_value = 1;
  int byte_value_size() const;
  void clear_byte_value();
  static const int kByteValueFieldNumber = 1;
  ::google::protobuf::int32 byte_value(int index) const;
  void set_byte_value(int index, ::google::protobuf::int32 value);
  void add_byte_value(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      byte_value() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_byte_value();

  // repeated int32 byte_index = 2;
  int byte_index_size() const;
  void clear_byte_index();
  static const int kByteIndexFieldNumber = 2;
  ::google::protobuf::int32 byte_index(int index) const;
  void set_byte_index(int index, ::google::protobuf::int32 value);
  void add_byte_index(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      byte_index() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_byte_index();

  // required int32 byte_count = 3;
  bool has_byte_count() const;
  void clear_byte_count();
  static const int kByteCountFieldNumber = 3;
  ::google::protobuf::int32 byte_count() const;
  void set_byte_count(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:Hekate.Protobuf.Proto.Client.ByteFilterMessage)
 private:
  inline void set_has_byte_count();
  inline void clear_has_byte_count();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > byte_value_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > byte_index_;
  ::google::protobuf::int32 byte_count_;
  friend void  protobuf_AddDesc_HekateClientProto_2eproto();
  friend void protobuf_AssignDesc_HekateClientProto_2eproto();
  friend void protobuf_ShutdownFile_HekateClientProto_2eproto();

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

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

  SubstringFilterMessage(const SubstringFilterMessage& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(SubstringFilterMessage* other);

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

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

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

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SubstringFilterMessage* other);
  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 -------------------------------------------------------

  // required bytes match = 1;
  bool has_match() const;
  void clear_match();
  static const int kMatchFieldNumber = 1;
  const ::std::string& match() const;
  void set_match(const ::std::string& value);
  void set_match(const char* value);
  void set_match(const void* value, size_t size);
  ::std::string* mutable_match();
  ::std::string* release_match();
  void set_allocated_match(::std::string* match);

  // required int32 length = 2;
  bool has_length() const;
  void clear_length();
  static const int kLengthFieldNumber = 2;
  ::google::protobuf::int32 length() const;
  void set_length(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:Hekate.Protobuf.Proto.Client.SubstringFilterMessage)
 private:
  inline void set_has_match();
  inline void clear_has_match();
  inline void set_has_length();
  inline void clear_has_length();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr match_;
  ::google::protobuf::int32 length_;
  friend void  protobuf_AddDesc_HekateClientProto_2eproto();
  friend void protobuf_AssignDesc_HekateClientProto_2eproto();
  friend void protobuf_ShutdownFile_HekateClientProto_2eproto();

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

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

  LengthFilterMessage(const LengthFilterMessage& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(LengthFilterMessage* other);

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

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

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

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LengthFilterMessage* other);
  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 -------------------------------------------------------

  // required int32 length_value = 1;
  bool has_length_value() const;
  void clear_length_value();
  static const int kLengthValueFieldNumber = 1;
  ::google::protobuf::int32 length_value() const;
  void set_length_value(::google::protobuf::int32 value);

  // required .Hekate.Protobuf.Proto.Client.LengthType length_type = 2;
  bool has_length_type() const;
  void clear_length_type();
  static const int kLengthTypeFieldNumber = 2;
  ::Hekate::Protobuf::Proto::Client::LengthType length_type() const;
  void set_length_type(::Hekate::Protobuf::Proto::Client::LengthType value);

  // @@protoc_insertion_point(class_scope:Hekate.Protobuf.Proto.Client.LengthFilterMessage)
 private:
  inline void set_has_length_value();
  inline void clear_has_length_value();
  inline void set_has_length_type();
  inline void clear_has_length_type();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::int32 length_value_;
  int length_type_;
  friend void  protobuf_AddDesc_HekateClientProto_2eproto();
  friend void protobuf_AssignDesc_HekateClientProto_2eproto();
  friend void protobuf_ShutdownFile_HekateClientProto_2eproto();

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

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

  SubstituteMessage(const SubstituteMessage& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(SubstituteMessage* other);

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

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

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

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SubstituteMessage* other);
  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 int32 byte_value = 1;
  int byte_value_size() const;
  void clear_byte_value();
  static const int kByteValueFieldNumber = 1;
  ::google::protobuf::int32 byte_value(int index) const;
  void set_byte_value(int index, ::google::protobuf::int32 value);
  void add_byte_value(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      byte_value() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_byte_value();

  // repeated int32 byte_index = 2;
  int byte_index_size() const;
  void clear_byte_index();
  static const int kByteIndexFieldNumber = 2;
  ::google::protobuf::int32 byte_index(int index) const;
  void set_byte_index(int index, ::google::protobuf::int32 value);
  void add_byte_index(::google::protobuf::int32 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
      byte_index() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
      mutable_byte_index();

  // required int32 byte_count = 3;
  bool has_byte_count() const;
  void clear_byte_count();
  static const int kByteCountFieldNumber = 3;
  ::google::protobuf::int32 byte_count() const;
  void set_byte_count(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:Hekate.Protobuf.Proto.Client.SubstituteMessage)
 private:
  inline void set_has_byte_count();
  inline void clear_has_byte_count();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > byte_value_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > byte_index_;
  ::google::protobuf::int32 byte_count_;
  friend void  protobuf_AddDesc_HekateClientProto_2eproto();
  friend void protobuf_AssignDesc_HekateClientProto_2eproto();
  friend void protobuf_ShutdownFile_HekateClientProto_2eproto();

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

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

  ReplacementMessage(const ReplacementMessage& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(ReplacementMessage* other);

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

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

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

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ReplacementMessage* other);
  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 -------------------------------------------------------

  // required bytes buffer = 1;
  bool has_buffer() const;
  void clear_buffer();
  static const int kBufferFieldNumber = 1;
  const ::std::string& buffer() const;
  void set_buffer(const ::std::string& value);
  void set_buffer(const char* value);
  void set_buffer(const void* value, size_t size);
  ::std::string* mutable_buffer();
  ::std::string* release_buffer();
  void set_allocated_buffer(::std::string* buffer);

  // required int32 length = 2;
  bool has_length() const;
  void clear_length();
  static const int kLengthFieldNumber = 2;
  ::google::protobuf::int32 length() const;
  void set_length(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:Hekate.Protobuf.Proto.Client.ReplacementMessage)
 private:
  inline void set_has_buffer();
  inline void clear_has_buffer();
  inline void set_has_length();
  inline void clear_has_length();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr buffer_;
  ::google::protobuf::int32 length_;
  friend void  protobuf_AddDesc_HekateClientProto_2eproto();
  friend void protobuf_AssignDesc_HekateClientProto_2eproto();
  friend void protobuf_ShutdownFile_HekateClientProto_2eproto();

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

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

  AddFilterMessage(const AddFilterMessage& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(AddFilterMessage* other);

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

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

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

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(AddFilterMessage* other);
  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 -------------------------------------------------------

  // required .Hekate.Protobuf.Proto.Client.FilterType type = 1;
  bool has_type() const;
  void clear_type();
  static const int kTypeFieldNumber = 1;
  ::Hekate::Protobuf::Proto::Client::FilterType type() const;
  void set_type(::Hekate::Protobuf::Proto::Client::FilterType value);

  // required int32 filter_id = 2;
  bool has_filter_id() const;
  void clear_filter_id();
  static const int kFilterIdFieldNumber = 2;
  ::google::protobuf::int32 filter_id() const;
  void set_filter_id(::google::protobuf::int32 value);

  // required bool break_on_hit = 3;
  bool has_break_on_hit() const;
  void clear_break_on_hit();
  static const int kBreakOnHitFieldNumber = 3;
  bool break_on_hit() const;
  void set_break_on_hit(bool value);

  // optional .Hekate.Protobuf.Proto.Client.ByteFilterMessage byte_filter = 4;
  bool has_byte_filter() const;
  void clear_byte_filter();
  static const int kByteFilterFieldNumber = 4;
  const ::Hekate::Protobuf::Proto::Client::ByteFilterMessage& byte_filter() const;
  ::Hekate::Protobuf::Proto::Client::ByteFilterMessage* mutable_byte_filter();
  ::Hekate::Protobuf::Proto::Client::ByteFilterMessage* release_byte_filter();
  void set_allocated_byte_filter(::Hekate::Protobuf::Proto::Client::ByteFilterMessage* byte_filter);

  // optional .Hekate.Protobuf.Proto.Client.LengthFilterMessage length_filter = 5;
  bool has_length_filter() const;
  void clear_length_filter();
  static const int kLengthFilterFieldNumber = 5;
  const ::Hekate::Protobuf::Proto::Client::LengthFilterMessage& length_filter() const;
  ::Hekate::Protobuf::Proto::Client::LengthFilterMessage* mutable_length_filter();
  ::Hekate::Protobuf::Proto::Client::LengthFilterMessage* release_length_filter();
  void set_allocated_length_filter(::Hekate::Protobuf::Proto::Client::LengthFilterMessage* length_filter);

  // optional .Hekate.Protobuf.Proto.Client.SubstringFilterMessage string_filter = 6;
  bool has_string_filter() const;
  void clear_string_filter();
  static const int kStringFilterFieldNumber = 6;
  const ::Hekate::Protobuf::Proto::Client::SubstringFilterMessage& string_filter() const;
  ::Hekate::Protobuf::Proto::Client::SubstringFilterMessage* mutable_string_filter();
  ::Hekate::Protobuf::Proto::Client::SubstringFilterMessage* release_string_filter();
  void set_allocated_string_filter(::Hekate::Protobuf::Proto::Client::SubstringFilterMessage* string_filter);

  // optional .Hekate.Protobuf.Proto.Client.SubstituteMessage substitute = 7;
  bool has_substitute() const;
  void clear_substitute();
  static const int kSubstituteFieldNumber = 7;
  const ::Hekate::Protobuf::Proto::Client::SubstituteMessage& substitute() const;
  ::Hekate::Protobuf::Proto::Client::SubstituteMessage* mutable_substitute();
  ::Hekate::Protobuf::Proto::Client::SubstituteMessage* release_substitute();
  void set_allocated_substitute(::Hekate::Protobuf::Proto::Client::SubstituteMessage* substitute);

  // optional .Hekate.Protobuf.Proto.Client.ReplacementMessage replacement = 8;
  bool has_replacement() const;
  void clear_replacement();
  static const int kReplacementFieldNumber = 8;
  const ::Hekate::Protobuf::Proto::Client::ReplacementMessage& replacement() const;
  ::Hekate::Protobuf::Proto::Client::ReplacementMessage* mutable_replacement();
  ::Hekate::Protobuf::Proto::Client::ReplacementMessage* release_replacement();
  void set_allocated_replacement(::Hekate::Protobuf::Proto::Client::ReplacementMessage* replacement);

  // @@protoc_insertion_point(class_scope:Hekate.Protobuf.Proto.Client.AddFilterMessage)
 private:
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_filter_id();
  inline void clear_has_filter_id();
  inline void set_has_break_on_hit();
  inline void clear_has_break_on_hit();
  inline void set_has_byte_filter();
  inline void clear_has_byte_filter();
  inline void set_has_length_filter();
  inline void clear_has_length_filter();
  inline void set_has_string_filter();
  inline void clear_has_string_filter();
  inline void set_has_substitute();
  inline void clear_has_substitute();
  inline void set_has_replacement();
  inline void clear_has_replacement();

  // helper for ByteSize()
  int RequiredFieldsByteSizeFallback() const;

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  int type_;
  ::google::protobuf::int32 filter_id_;
  ::Hekate::Protobuf::Proto::Client::ByteFilterMessage* byte_filter_;
  ::Hekate::Protobuf::Proto::Client::LengthFilterMessage* length_filter_;
  ::Hekate::Protobuf::Proto::Client::SubstringFilterMessage* string_filter_;
  ::Hekate::Protobuf::Proto::Client::SubstituteMessage* substitute_;
  ::Hekate::Protobuf::Proto::Client::ReplacementMessage* replacement_;
  bool break_on_hit_;
  friend void  protobuf_AddDesc_HekateClientProto_2eproto();
  friend void protobuf_AssignDesc_HekateClientProto_2eproto();
  friend void protobuf_ShutdownFile_HekateClientProto_2eproto();

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

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

  RemoveFilterMessage(const RemoveFilterMessage& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(RemoveFilterMessage* other);

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

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

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

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RemoveFilterMessage* other);
  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 -------------------------------------------------------

  // required int32 filter_id = 1;
  bool has_filter_id() const;
  void clear_filter_id();
  static const int kFilterIdFieldNumber = 1;
  ::google::protobuf::int32 filter_id() const;
  void set_filter_id(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:Hekate.Protobuf.Proto.Client.RemoveFilterMessage)
 private:
  inline void set_has_filter_id();
  inline void clear_has_filter_id();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::google::protobuf::int32 filter_id_;
  friend void  protobuf_AddDesc_HekateClientProto_2eproto();
  friend void protobuf_AssignDesc_HekateClientProto_2eproto();
  friend void protobuf_ShutdownFile_HekateClientProto_2eproto();

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

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

  ReplayMessage(const ReplayMessage& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(ReplayMessage* other);

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

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

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

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ReplayMessage* other);
  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 -------------------------------------------------------

  // required .Hekate.Protobuf.Proto.Server.HekateToClientMessage message = 1;
  bool has_message() const;
  void clear_message();
  static const int kMessageFieldNumber = 1;
  const ::Hekate::Protobuf::Proto::Server::HekateToClientMessage& message() const;
  ::Hekate::Protobuf::Proto::Server::HekateToClientMessage* mutable_message();
  ::Hekate::Protobuf::Proto::Server::HekateToClientMessage* release_message();
  void set_allocated_message(::Hekate::Protobuf::Proto::Server::HekateToClientMessage* message);

  // @@protoc_insertion_point(class_scope:Hekate.Protobuf.Proto.Client.ReplayMessage)
 private:
  inline void set_has_message();
  inline void clear_has_message();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::Hekate::Protobuf::Proto::Server::HekateToClientMessage* message_;
  friend void  protobuf_AddDesc_HekateClientProto_2eproto();
  friend void protobuf_AssignDesc_HekateClientProto_2eproto();
  friend void protobuf_ShutdownFile_HekateClientProto_2eproto();

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

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

  ClientToHekateMessage(const ClientToHekateMessage& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(ClientToHekateMessage* other);

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

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

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

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ClientToHekateMessage* other);
  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 -------------------------------------------------------

  // required .Hekate.Protobuf.Proto.Client.MessageType type = 1;
  bool has_type() const;
  void clear_type();
  static const int kTypeFieldNumber = 1;
  ::Hekate::Protobuf::Proto::Client::MessageType type() const;
  void set_type(::Hekate::Protobuf::Proto::Client::MessageType value);

  // optional .Hekate.Protobuf.Proto.Client.AddHookMessage add_hook = 2;
  bool has_add_hook() const;
  void clear_add_hook();
  static const int kAddHookFieldNumber = 2;
  const ::Hekate::Protobuf::Proto::Client::AddHookMessage& add_hook() const;
  ::Hekate::Protobuf::Proto::Client::AddHookMessage* mutable_add_hook();
  ::Hekate::Protobuf::Proto::Client::AddHookMessage* release_add_hook();
  void set_allocated_add_hook(::Hekate::Protobuf::Proto::Client::AddHookMessage* add_hook);

  // optional .Hekate.Protobuf.Proto.Client.RemoveHookMessage remove_hook = 3;
  bool has_remove_hook() const;
  void clear_remove_hook();
  static const int kRemoveHookFieldNumber = 3;
  const ::Hekate::Protobuf::Proto::Client::RemoveHookMessage& remove_hook() const;
  ::Hekate::Protobuf::Proto::Client::RemoveHookMessage* mutable_remove_hook();
  ::Hekate::Protobuf::Proto::Client::RemoveHookMessage* release_remove_hook();
  void set_allocated_remove_hook(::Hekate::Protobuf::Proto::Client::RemoveHookMessage* remove_hook);

  // optional .Hekate.Protobuf.Proto.Client.AddFilterMessage add_filter = 4;
  bool has_add_filter() const;
  void clear_add_filter();
  static const int kAddFilterFieldNumber = 4;
  const ::Hekate::Protobuf::Proto::Client::AddFilterMessage& add_filter() const;
  ::Hekate::Protobuf::Proto::Client::AddFilterMessage* mutable_add_filter();
  ::Hekate::Protobuf::Proto::Client::AddFilterMessage* release_add_filter();
  void set_allocated_add_filter(::Hekate::Protobuf::Proto::Client::AddFilterMessage* add_filter);

  // optional .Hekate.Protobuf.Proto.Client.RemoveFilterMessage remove_filter = 5;
  bool has_remove_filter() const;
  void clear_remove_filter();
  static const int kRemoveFilterFieldNumber = 5;
  const ::Hekate::Protobuf::Proto::Client::RemoveFilterMessage& remove_filter() const;
  ::Hekate::Protobuf::Proto::Client::RemoveFilterMessage* mutable_remove_filter();
  ::Hekate::Protobuf::Proto::Client::RemoveFilterMessage* release_remove_filter();
  void set_allocated_remove_filter(::Hekate::Protobuf::Proto::Client::RemoveFilterMessage* remove_filter);

  // optional .Hekate.Protobuf.Proto.Client.ReplayMessage replay = 6;
  bool has_replay() const;
  void clear_replay();
  static const int kReplayFieldNumber = 6;
  const ::Hekate::Protobuf::Proto::Client::ReplayMessage& replay() const;
  ::Hekate::Protobuf::Proto::Client::ReplayMessage* mutable_replay();
  ::Hekate::Protobuf::Proto::Client::ReplayMessage* release_replay();
  void set_allocated_replay(::Hekate::Protobuf::Proto::Client::ReplayMessage* replay);

  // optional bool continue = 7;
  bool has_continue_() const;
  void clear_continue_();
  static const int kContinueFieldNumber = 7;
  bool continue_() const;
  void set_continue_(bool value);

  // @@protoc_insertion_point(class_scope:Hekate.Protobuf.Proto.Client.ClientToHekateMessage)
 private:
  inline void set_has_type();
  inline void clear_has_type();
  inline void set_has_add_hook();
  inline void clear_has_add_hook();
  inline void set_has_remove_hook();
  inline void clear_has_remove_hook();
  inline void set_has_add_filter();
  inline void clear_has_add_filter();
  inline void set_has_remove_filter();
  inline void clear_has_remove_filter();
  inline void set_has_replay();
  inline void clear_has_replay();
  inline void set_has_continue_();
  inline void clear_has_continue_();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::Hekate::Protobuf::Proto::Client::AddHookMessage* add_hook_;
  ::Hekate::Protobuf::Proto::Client::RemoveHookMessage* remove_hook_;
  ::Hekate::Protobuf::Proto::Client::AddFilterMessage* add_filter_;
  int type_;
  bool continue__;
  ::Hekate::Protobuf::Proto::Client::RemoveFilterMessage* remove_filter_;
  ::Hekate::Protobuf::Proto::Client::ReplayMessage* replay_;
  friend void  protobuf_AddDesc_HekateClientProto_2eproto();
  friend void protobuf_AssignDesc_HekateClientProto_2eproto();
  friend void protobuf_ShutdownFile_HekateClientProto_2eproto();

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

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

  HekateClientMessage(const HekateClientMessage& from);

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

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

  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

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

  void Swap(HekateClientMessage* other);

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

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

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

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(HekateClientMessage* other);
  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 -------------------------------------------------------

  // required .Hekate.Protobuf.Proto.Client.ClientToHekateMessage clientMessage = 1;
  bool has_clientmessage() const;
  void clear_clientmessage();
  static const int kClientMessageFieldNumber = 1;
  const ::Hekate::Protobuf::Proto::Client::ClientToHekateMessage& clientmessage() const;
  ::Hekate::Protobuf::Proto::Client::ClientToHekateMessage* mutable_clientmessage();
  ::Hekate::Protobuf::Proto::Client::ClientToHekateMessage* release_clientmessage();
  void set_allocated_clientmessage(::Hekate::Protobuf::Proto::Client::ClientToHekateMessage* clientmessage);

  // optional int32 debug_response_id = 2;
  bool has_debug_response_id() const;
  void clear_debug_response_id();
  static const int kDebugResponseIdFieldNumber = 2;
  ::google::protobuf::int32 debug_response_id() const;
  void set_debug_response_id(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:Hekate.Protobuf.Proto.Client.HekateClientMessage)
 private:
  inline void set_has_clientmessage();
  inline void clear_has_clientmessage();
  inline void set_has_debug_response_id();
  inline void clear_has_debug_response_id();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::Hekate::Protobuf::Proto::Client::ClientToHekateMessage* clientmessage_;
  ::google::protobuf::int32 debug_response_id_;
  friend void  protobuf_AddDesc_HekateClientProto_2eproto();
  friend void protobuf_AssignDesc_HekateClientProto_2eproto();
  friend void protobuf_ShutdownFile_HekateClientProto_2eproto();

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


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

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
// AddHookMessage

// required string name = 1;
inline bool AddHookMessage::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AddHookMessage::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AddHookMessage::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AddHookMessage::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_name();
}
inline const ::std::string& AddHookMessage::name() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddHookMessage.name)
  return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AddHookMessage::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.AddHookMessage.name)
}
inline void AddHookMessage::set_name(const char* value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:Hekate.Protobuf.Proto.Client.AddHookMessage.name)
}
inline void AddHookMessage::set_name(const char* value, size_t size) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:Hekate.Protobuf.Proto.Client.AddHookMessage.name)
}
inline ::std::string* AddHookMessage::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.AddHookMessage.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AddHookMessage::release_name() {
  clear_has_name();
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AddHookMessage::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    set_has_name();
  } else {
    clear_has_name();
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.AddHookMessage.name)
}

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

// RemoveHookMessage

// required string name = 1;
inline bool RemoveHookMessage::has_name() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RemoveHookMessage::set_has_name() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RemoveHookMessage::clear_has_name() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RemoveHookMessage::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_name();
}
inline const ::std::string& RemoveHookMessage::name() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.RemoveHookMessage.name)
  return name_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RemoveHookMessage::set_name(const ::std::string& value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.RemoveHookMessage.name)
}
inline void RemoveHookMessage::set_name(const char* value) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:Hekate.Protobuf.Proto.Client.RemoveHookMessage.name)
}
inline void RemoveHookMessage::set_name(const char* value, size_t size) {
  set_has_name();
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:Hekate.Protobuf.Proto.Client.RemoveHookMessage.name)
}
inline ::std::string* RemoveHookMessage::mutable_name() {
  set_has_name();
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.RemoveHookMessage.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RemoveHookMessage::release_name() {
  clear_has_name();
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RemoveHookMessage::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    set_has_name();
  } else {
    clear_has_name();
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.RemoveHookMessage.name)
}

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

// ByteFilterMessage

// repeated int32 byte_value = 1;
inline int ByteFilterMessage::byte_value_size() const {
  return byte_value_.size();
}
inline void ByteFilterMessage::clear_byte_value() {
  byte_value_.Clear();
}
inline ::google::protobuf::int32 ByteFilterMessage::byte_value(int index) const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_value)
  return byte_value_.Get(index);
}
inline void ByteFilterMessage::set_byte_value(int index, ::google::protobuf::int32 value) {
  byte_value_.Set(index, value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_value)
}
inline void ByteFilterMessage::add_byte_value(::google::protobuf::int32 value) {
  byte_value_.Add(value);
  // @@protoc_insertion_point(field_add:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_value)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ByteFilterMessage::byte_value() const {
  // @@protoc_insertion_point(field_list:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_value)
  return byte_value_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ByteFilterMessage::mutable_byte_value() {
  // @@protoc_insertion_point(field_mutable_list:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_value)
  return &byte_value_;
}

// repeated int32 byte_index = 2;
inline int ByteFilterMessage::byte_index_size() const {
  return byte_index_.size();
}
inline void ByteFilterMessage::clear_byte_index() {
  byte_index_.Clear();
}
inline ::google::protobuf::int32 ByteFilterMessage::byte_index(int index) const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_index)
  return byte_index_.Get(index);
}
inline void ByteFilterMessage::set_byte_index(int index, ::google::protobuf::int32 value) {
  byte_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_index)
}
inline void ByteFilterMessage::add_byte_index(::google::protobuf::int32 value) {
  byte_index_.Add(value);
  // @@protoc_insertion_point(field_add:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_index)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
ByteFilterMessage::byte_index() const {
  // @@protoc_insertion_point(field_list:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_index)
  return byte_index_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
ByteFilterMessage::mutable_byte_index() {
  // @@protoc_insertion_point(field_mutable_list:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_index)
  return &byte_index_;
}

// required int32 byte_count = 3;
inline bool ByteFilterMessage::has_byte_count() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ByteFilterMessage::set_has_byte_count() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ByteFilterMessage::clear_has_byte_count() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ByteFilterMessage::clear_byte_count() {
  byte_count_ = 0;
  clear_has_byte_count();
}
inline ::google::protobuf::int32 ByteFilterMessage::byte_count() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_count)
  return byte_count_;
}
inline void ByteFilterMessage::set_byte_count(::google::protobuf::int32 value) {
  set_has_byte_count();
  byte_count_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.ByteFilterMessage.byte_count)
}

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

// SubstringFilterMessage

// required bytes match = 1;
inline bool SubstringFilterMessage::has_match() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SubstringFilterMessage::set_has_match() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SubstringFilterMessage::clear_has_match() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SubstringFilterMessage::clear_match() {
  match_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_match();
}
inline const ::std::string& SubstringFilterMessage::match() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.SubstringFilterMessage.match)
  return match_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SubstringFilterMessage::set_match(const ::std::string& value) {
  set_has_match();
  match_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.SubstringFilterMessage.match)
}
inline void SubstringFilterMessage::set_match(const char* value) {
  set_has_match();
  match_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:Hekate.Protobuf.Proto.Client.SubstringFilterMessage.match)
}
inline void SubstringFilterMessage::set_match(const void* value, size_t size) {
  set_has_match();
  match_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:Hekate.Protobuf.Proto.Client.SubstringFilterMessage.match)
}
inline ::std::string* SubstringFilterMessage::mutable_match() {
  set_has_match();
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.SubstringFilterMessage.match)
  return match_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SubstringFilterMessage::release_match() {
  clear_has_match();
  return match_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SubstringFilterMessage::set_allocated_match(::std::string* match) {
  if (match != NULL) {
    set_has_match();
  } else {
    clear_has_match();
  }
  match_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), match);
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.SubstringFilterMessage.match)
}

// required int32 length = 2;
inline bool SubstringFilterMessage::has_length() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void SubstringFilterMessage::set_has_length() {
  _has_bits_[0] |= 0x00000002u;
}
inline void SubstringFilterMessage::clear_has_length() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void SubstringFilterMessage::clear_length() {
  length_ = 0;
  clear_has_length();
}
inline ::google::protobuf::int32 SubstringFilterMessage::length() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.SubstringFilterMessage.length)
  return length_;
}
inline void SubstringFilterMessage::set_length(::google::protobuf::int32 value) {
  set_has_length();
  length_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.SubstringFilterMessage.length)
}

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

// LengthFilterMessage

// required int32 length_value = 1;
inline bool LengthFilterMessage::has_length_value() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LengthFilterMessage::set_has_length_value() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LengthFilterMessage::clear_has_length_value() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LengthFilterMessage::clear_length_value() {
  length_value_ = 0;
  clear_has_length_value();
}
inline ::google::protobuf::int32 LengthFilterMessage::length_value() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.LengthFilterMessage.length_value)
  return length_value_;
}
inline void LengthFilterMessage::set_length_value(::google::protobuf::int32 value) {
  set_has_length_value();
  length_value_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.LengthFilterMessage.length_value)
}

// required .Hekate.Protobuf.Proto.Client.LengthType length_type = 2;
inline bool LengthFilterMessage::has_length_type() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LengthFilterMessage::set_has_length_type() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LengthFilterMessage::clear_has_length_type() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void LengthFilterMessage::clear_length_type() {
  length_type_ = 0;
  clear_has_length_type();
}
inline ::Hekate::Protobuf::Proto::Client::LengthType LengthFilterMessage::length_type() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.LengthFilterMessage.length_type)
  return static_cast< ::Hekate::Protobuf::Proto::Client::LengthType >(length_type_);
}
inline void LengthFilterMessage::set_length_type(::Hekate::Protobuf::Proto::Client::LengthType value) {
  assert(::Hekate::Protobuf::Proto::Client::LengthType_IsValid(value));
  set_has_length_type();
  length_type_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.LengthFilterMessage.length_type)
}

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

// SubstituteMessage

// repeated int32 byte_value = 1;
inline int SubstituteMessage::byte_value_size() const {
  return byte_value_.size();
}
inline void SubstituteMessage::clear_byte_value() {
  byte_value_.Clear();
}
inline ::google::protobuf::int32 SubstituteMessage::byte_value(int index) const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_value)
  return byte_value_.Get(index);
}
inline void SubstituteMessage::set_byte_value(int index, ::google::protobuf::int32 value) {
  byte_value_.Set(index, value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_value)
}
inline void SubstituteMessage::add_byte_value(::google::protobuf::int32 value) {
  byte_value_.Add(value);
  // @@protoc_insertion_point(field_add:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_value)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
SubstituteMessage::byte_value() const {
  // @@protoc_insertion_point(field_list:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_value)
  return byte_value_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
SubstituteMessage::mutable_byte_value() {
  // @@protoc_insertion_point(field_mutable_list:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_value)
  return &byte_value_;
}

// repeated int32 byte_index = 2;
inline int SubstituteMessage::byte_index_size() const {
  return byte_index_.size();
}
inline void SubstituteMessage::clear_byte_index() {
  byte_index_.Clear();
}
inline ::google::protobuf::int32 SubstituteMessage::byte_index(int index) const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_index)
  return byte_index_.Get(index);
}
inline void SubstituteMessage::set_byte_index(int index, ::google::protobuf::int32 value) {
  byte_index_.Set(index, value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_index)
}
inline void SubstituteMessage::add_byte_index(::google::protobuf::int32 value) {
  byte_index_.Add(value);
  // @@protoc_insertion_point(field_add:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_index)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
SubstituteMessage::byte_index() const {
  // @@protoc_insertion_point(field_list:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_index)
  return byte_index_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
SubstituteMessage::mutable_byte_index() {
  // @@protoc_insertion_point(field_mutable_list:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_index)
  return &byte_index_;
}

// required int32 byte_count = 3;
inline bool SubstituteMessage::has_byte_count() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void SubstituteMessage::set_has_byte_count() {
  _has_bits_[0] |= 0x00000004u;
}
inline void SubstituteMessage::clear_has_byte_count() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void SubstituteMessage::clear_byte_count() {
  byte_count_ = 0;
  clear_has_byte_count();
}
inline ::google::protobuf::int32 SubstituteMessage::byte_count() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_count)
  return byte_count_;
}
inline void SubstituteMessage::set_byte_count(::google::protobuf::int32 value) {
  set_has_byte_count();
  byte_count_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.SubstituteMessage.byte_count)
}

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

// ReplacementMessage

// required bytes buffer = 1;
inline bool ReplacementMessage::has_buffer() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReplacementMessage::set_has_buffer() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ReplacementMessage::clear_has_buffer() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ReplacementMessage::clear_buffer() {
  buffer_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_buffer();
}
inline const ::std::string& ReplacementMessage::buffer() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ReplacementMessage.buffer)
  return buffer_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReplacementMessage::set_buffer(const ::std::string& value) {
  set_has_buffer();
  buffer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.ReplacementMessage.buffer)
}
inline void ReplacementMessage::set_buffer(const char* value) {
  set_has_buffer();
  buffer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:Hekate.Protobuf.Proto.Client.ReplacementMessage.buffer)
}
inline void ReplacementMessage::set_buffer(const void* value, size_t size) {
  set_has_buffer();
  buffer_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:Hekate.Protobuf.Proto.Client.ReplacementMessage.buffer)
}
inline ::std::string* ReplacementMessage::mutable_buffer() {
  set_has_buffer();
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.ReplacementMessage.buffer)
  return buffer_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ReplacementMessage::release_buffer() {
  clear_has_buffer();
  return buffer_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReplacementMessage::set_allocated_buffer(::std::string* buffer) {
  if (buffer != NULL) {
    set_has_buffer();
  } else {
    clear_has_buffer();
  }
  buffer_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), buffer);
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.ReplacementMessage.buffer)
}

// required int32 length = 2;
inline bool ReplacementMessage::has_length() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ReplacementMessage::set_has_length() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ReplacementMessage::clear_has_length() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ReplacementMessage::clear_length() {
  length_ = 0;
  clear_has_length();
}
inline ::google::protobuf::int32 ReplacementMessage::length() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ReplacementMessage.length)
  return length_;
}
inline void ReplacementMessage::set_length(::google::protobuf::int32 value) {
  set_has_length();
  length_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.ReplacementMessage.length)
}

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

// AddFilterMessage

// required .Hekate.Protobuf.Proto.Client.FilterType type = 1;
inline bool AddFilterMessage::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AddFilterMessage::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AddFilterMessage::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AddFilterMessage::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::Hekate::Protobuf::Proto::Client::FilterType AddFilterMessage::type() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddFilterMessage.type)
  return static_cast< ::Hekate::Protobuf::Proto::Client::FilterType >(type_);
}
inline void AddFilterMessage::set_type(::Hekate::Protobuf::Proto::Client::FilterType value) {
  assert(::Hekate::Protobuf::Proto::Client::FilterType_IsValid(value));
  set_has_type();
  type_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.AddFilterMessage.type)
}

// required int32 filter_id = 2;
inline bool AddFilterMessage::has_filter_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void AddFilterMessage::set_has_filter_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void AddFilterMessage::clear_has_filter_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void AddFilterMessage::clear_filter_id() {
  filter_id_ = 0;
  clear_has_filter_id();
}
inline ::google::protobuf::int32 AddFilterMessage::filter_id() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddFilterMessage.filter_id)
  return filter_id_;
}
inline void AddFilterMessage::set_filter_id(::google::protobuf::int32 value) {
  set_has_filter_id();
  filter_id_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.AddFilterMessage.filter_id)
}

// required bool break_on_hit = 3;
inline bool AddFilterMessage::has_break_on_hit() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void AddFilterMessage::set_has_break_on_hit() {
  _has_bits_[0] |= 0x00000004u;
}
inline void AddFilterMessage::clear_has_break_on_hit() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void AddFilterMessage::clear_break_on_hit() {
  break_on_hit_ = false;
  clear_has_break_on_hit();
}
inline bool AddFilterMessage::break_on_hit() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddFilterMessage.break_on_hit)
  return break_on_hit_;
}
inline void AddFilterMessage::set_break_on_hit(bool value) {
  set_has_break_on_hit();
  break_on_hit_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.AddFilterMessage.break_on_hit)
}

// optional .Hekate.Protobuf.Proto.Client.ByteFilterMessage byte_filter = 4;
inline bool AddFilterMessage::has_byte_filter() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void AddFilterMessage::set_has_byte_filter() {
  _has_bits_[0] |= 0x00000008u;
}
inline void AddFilterMessage::clear_has_byte_filter() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void AddFilterMessage::clear_byte_filter() {
  if (byte_filter_ != NULL) byte_filter_->::Hekate::Protobuf::Proto::Client::ByteFilterMessage::Clear();
  clear_has_byte_filter();
}
inline const ::Hekate::Protobuf::Proto::Client::ByteFilterMessage& AddFilterMessage::byte_filter() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddFilterMessage.byte_filter)
  return byte_filter_ != NULL ? *byte_filter_ : *default_instance_->byte_filter_;
}
inline ::Hekate::Protobuf::Proto::Client::ByteFilterMessage* AddFilterMessage::mutable_byte_filter() {
  set_has_byte_filter();
  if (byte_filter_ == NULL) {
    byte_filter_ = new ::Hekate::Protobuf::Proto::Client::ByteFilterMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.AddFilterMessage.byte_filter)
  return byte_filter_;
}
inline ::Hekate::Protobuf::Proto::Client::ByteFilterMessage* AddFilterMessage::release_byte_filter() {
  clear_has_byte_filter();
  ::Hekate::Protobuf::Proto::Client::ByteFilterMessage* temp = byte_filter_;
  byte_filter_ = NULL;
  return temp;
}
inline void AddFilterMessage::set_allocated_byte_filter(::Hekate::Protobuf::Proto::Client::ByteFilterMessage* byte_filter) {
  delete byte_filter_;
  byte_filter_ = byte_filter;
  if (byte_filter) {
    set_has_byte_filter();
  } else {
    clear_has_byte_filter();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.AddFilterMessage.byte_filter)
}

// optional .Hekate.Protobuf.Proto.Client.LengthFilterMessage length_filter = 5;
inline bool AddFilterMessage::has_length_filter() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void AddFilterMessage::set_has_length_filter() {
  _has_bits_[0] |= 0x00000010u;
}
inline void AddFilterMessage::clear_has_length_filter() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void AddFilterMessage::clear_length_filter() {
  if (length_filter_ != NULL) length_filter_->::Hekate::Protobuf::Proto::Client::LengthFilterMessage::Clear();
  clear_has_length_filter();
}
inline const ::Hekate::Protobuf::Proto::Client::LengthFilterMessage& AddFilterMessage::length_filter() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddFilterMessage.length_filter)
  return length_filter_ != NULL ? *length_filter_ : *default_instance_->length_filter_;
}
inline ::Hekate::Protobuf::Proto::Client::LengthFilterMessage* AddFilterMessage::mutable_length_filter() {
  set_has_length_filter();
  if (length_filter_ == NULL) {
    length_filter_ = new ::Hekate::Protobuf::Proto::Client::LengthFilterMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.AddFilterMessage.length_filter)
  return length_filter_;
}
inline ::Hekate::Protobuf::Proto::Client::LengthFilterMessage* AddFilterMessage::release_length_filter() {
  clear_has_length_filter();
  ::Hekate::Protobuf::Proto::Client::LengthFilterMessage* temp = length_filter_;
  length_filter_ = NULL;
  return temp;
}
inline void AddFilterMessage::set_allocated_length_filter(::Hekate::Protobuf::Proto::Client::LengthFilterMessage* length_filter) {
  delete length_filter_;
  length_filter_ = length_filter;
  if (length_filter) {
    set_has_length_filter();
  } else {
    clear_has_length_filter();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.AddFilterMessage.length_filter)
}

// optional .Hekate.Protobuf.Proto.Client.SubstringFilterMessage string_filter = 6;
inline bool AddFilterMessage::has_string_filter() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void AddFilterMessage::set_has_string_filter() {
  _has_bits_[0] |= 0x00000020u;
}
inline void AddFilterMessage::clear_has_string_filter() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void AddFilterMessage::clear_string_filter() {
  if (string_filter_ != NULL) string_filter_->::Hekate::Protobuf::Proto::Client::SubstringFilterMessage::Clear();
  clear_has_string_filter();
}
inline const ::Hekate::Protobuf::Proto::Client::SubstringFilterMessage& AddFilterMessage::string_filter() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddFilterMessage.string_filter)
  return string_filter_ != NULL ? *string_filter_ : *default_instance_->string_filter_;
}
inline ::Hekate::Protobuf::Proto::Client::SubstringFilterMessage* AddFilterMessage::mutable_string_filter() {
  set_has_string_filter();
  if (string_filter_ == NULL) {
    string_filter_ = new ::Hekate::Protobuf::Proto::Client::SubstringFilterMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.AddFilterMessage.string_filter)
  return string_filter_;
}
inline ::Hekate::Protobuf::Proto::Client::SubstringFilterMessage* AddFilterMessage::release_string_filter() {
  clear_has_string_filter();
  ::Hekate::Protobuf::Proto::Client::SubstringFilterMessage* temp = string_filter_;
  string_filter_ = NULL;
  return temp;
}
inline void AddFilterMessage::set_allocated_string_filter(::Hekate::Protobuf::Proto::Client::SubstringFilterMessage* string_filter) {
  delete string_filter_;
  string_filter_ = string_filter;
  if (string_filter) {
    set_has_string_filter();
  } else {
    clear_has_string_filter();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.AddFilterMessage.string_filter)
}

// optional .Hekate.Protobuf.Proto.Client.SubstituteMessage substitute = 7;
inline bool AddFilterMessage::has_substitute() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void AddFilterMessage::set_has_substitute() {
  _has_bits_[0] |= 0x00000040u;
}
inline void AddFilterMessage::clear_has_substitute() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void AddFilterMessage::clear_substitute() {
  if (substitute_ != NULL) substitute_->::Hekate::Protobuf::Proto::Client::SubstituteMessage::Clear();
  clear_has_substitute();
}
inline const ::Hekate::Protobuf::Proto::Client::SubstituteMessage& AddFilterMessage::substitute() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddFilterMessage.substitute)
  return substitute_ != NULL ? *substitute_ : *default_instance_->substitute_;
}
inline ::Hekate::Protobuf::Proto::Client::SubstituteMessage* AddFilterMessage::mutable_substitute() {
  set_has_substitute();
  if (substitute_ == NULL) {
    substitute_ = new ::Hekate::Protobuf::Proto::Client::SubstituteMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.AddFilterMessage.substitute)
  return substitute_;
}
inline ::Hekate::Protobuf::Proto::Client::SubstituteMessage* AddFilterMessage::release_substitute() {
  clear_has_substitute();
  ::Hekate::Protobuf::Proto::Client::SubstituteMessage* temp = substitute_;
  substitute_ = NULL;
  return temp;
}
inline void AddFilterMessage::set_allocated_substitute(::Hekate::Protobuf::Proto::Client::SubstituteMessage* substitute) {
  delete substitute_;
  substitute_ = substitute;
  if (substitute) {
    set_has_substitute();
  } else {
    clear_has_substitute();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.AddFilterMessage.substitute)
}

// optional .Hekate.Protobuf.Proto.Client.ReplacementMessage replacement = 8;
inline bool AddFilterMessage::has_replacement() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void AddFilterMessage::set_has_replacement() {
  _has_bits_[0] |= 0x00000080u;
}
inline void AddFilterMessage::clear_has_replacement() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void AddFilterMessage::clear_replacement() {
  if (replacement_ != NULL) replacement_->::Hekate::Protobuf::Proto::Client::ReplacementMessage::Clear();
  clear_has_replacement();
}
inline const ::Hekate::Protobuf::Proto::Client::ReplacementMessage& AddFilterMessage::replacement() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.AddFilterMessage.replacement)
  return replacement_ != NULL ? *replacement_ : *default_instance_->replacement_;
}
inline ::Hekate::Protobuf::Proto::Client::ReplacementMessage* AddFilterMessage::mutable_replacement() {
  set_has_replacement();
  if (replacement_ == NULL) {
    replacement_ = new ::Hekate::Protobuf::Proto::Client::ReplacementMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.AddFilterMessage.replacement)
  return replacement_;
}
inline ::Hekate::Protobuf::Proto::Client::ReplacementMessage* AddFilterMessage::release_replacement() {
  clear_has_replacement();
  ::Hekate::Protobuf::Proto::Client::ReplacementMessage* temp = replacement_;
  replacement_ = NULL;
  return temp;
}
inline void AddFilterMessage::set_allocated_replacement(::Hekate::Protobuf::Proto::Client::ReplacementMessage* replacement) {
  delete replacement_;
  replacement_ = replacement;
  if (replacement) {
    set_has_replacement();
  } else {
    clear_has_replacement();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.AddFilterMessage.replacement)
}

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

// RemoveFilterMessage

// required int32 filter_id = 1;
inline bool RemoveFilterMessage::has_filter_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RemoveFilterMessage::set_has_filter_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RemoveFilterMessage::clear_has_filter_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RemoveFilterMessage::clear_filter_id() {
  filter_id_ = 0;
  clear_has_filter_id();
}
inline ::google::protobuf::int32 RemoveFilterMessage::filter_id() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.RemoveFilterMessage.filter_id)
  return filter_id_;
}
inline void RemoveFilterMessage::set_filter_id(::google::protobuf::int32 value) {
  set_has_filter_id();
  filter_id_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.RemoveFilterMessage.filter_id)
}

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

// ReplayMessage

// required .Hekate.Protobuf.Proto.Server.HekateToClientMessage message = 1;
inline bool ReplayMessage::has_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReplayMessage::set_has_message() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ReplayMessage::clear_has_message() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ReplayMessage::clear_message() {
  if (message_ != NULL) message_->::Hekate::Protobuf::Proto::Server::HekateToClientMessage::Clear();
  clear_has_message();
}
inline const ::Hekate::Protobuf::Proto::Server::HekateToClientMessage& ReplayMessage::message() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ReplayMessage.message)
  return message_ != NULL ? *message_ : *default_instance_->message_;
}
inline ::Hekate::Protobuf::Proto::Server::HekateToClientMessage* ReplayMessage::mutable_message() {
  set_has_message();
  if (message_ == NULL) {
    message_ = new ::Hekate::Protobuf::Proto::Server::HekateToClientMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.ReplayMessage.message)
  return message_;
}
inline ::Hekate::Protobuf::Proto::Server::HekateToClientMessage* ReplayMessage::release_message() {
  clear_has_message();
  ::Hekate::Protobuf::Proto::Server::HekateToClientMessage* temp = message_;
  message_ = NULL;
  return temp;
}
inline void ReplayMessage::set_allocated_message(::Hekate::Protobuf::Proto::Server::HekateToClientMessage* message) {
  delete message_;
  message_ = message;
  if (message) {
    set_has_message();
  } else {
    clear_has_message();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.ReplayMessage.message)
}

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

// ClientToHekateMessage

// required .Hekate.Protobuf.Proto.Client.MessageType type = 1;
inline bool ClientToHekateMessage::has_type() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ClientToHekateMessage::set_has_type() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ClientToHekateMessage::clear_has_type() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ClientToHekateMessage::clear_type() {
  type_ = 0;
  clear_has_type();
}
inline ::Hekate::Protobuf::Proto::Client::MessageType ClientToHekateMessage::type() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.type)
  return static_cast< ::Hekate::Protobuf::Proto::Client::MessageType >(type_);
}
inline void ClientToHekateMessage::set_type(::Hekate::Protobuf::Proto::Client::MessageType value) {
  assert(::Hekate::Protobuf::Proto::Client::MessageType_IsValid(value));
  set_has_type();
  type_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.type)
}

// optional .Hekate.Protobuf.Proto.Client.AddHookMessage add_hook = 2;
inline bool ClientToHekateMessage::has_add_hook() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ClientToHekateMessage::set_has_add_hook() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ClientToHekateMessage::clear_has_add_hook() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ClientToHekateMessage::clear_add_hook() {
  if (add_hook_ != NULL) add_hook_->::Hekate::Protobuf::Proto::Client::AddHookMessage::Clear();
  clear_has_add_hook();
}
inline const ::Hekate::Protobuf::Proto::Client::AddHookMessage& ClientToHekateMessage::add_hook() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.add_hook)
  return add_hook_ != NULL ? *add_hook_ : *default_instance_->add_hook_;
}
inline ::Hekate::Protobuf::Proto::Client::AddHookMessage* ClientToHekateMessage::mutable_add_hook() {
  set_has_add_hook();
  if (add_hook_ == NULL) {
    add_hook_ = new ::Hekate::Protobuf::Proto::Client::AddHookMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.add_hook)
  return add_hook_;
}
inline ::Hekate::Protobuf::Proto::Client::AddHookMessage* ClientToHekateMessage::release_add_hook() {
  clear_has_add_hook();
  ::Hekate::Protobuf::Proto::Client::AddHookMessage* temp = add_hook_;
  add_hook_ = NULL;
  return temp;
}
inline void ClientToHekateMessage::set_allocated_add_hook(::Hekate::Protobuf::Proto::Client::AddHookMessage* add_hook) {
  delete add_hook_;
  add_hook_ = add_hook;
  if (add_hook) {
    set_has_add_hook();
  } else {
    clear_has_add_hook();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.add_hook)
}

// optional .Hekate.Protobuf.Proto.Client.RemoveHookMessage remove_hook = 3;
inline bool ClientToHekateMessage::has_remove_hook() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ClientToHekateMessage::set_has_remove_hook() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ClientToHekateMessage::clear_has_remove_hook() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ClientToHekateMessage::clear_remove_hook() {
  if (remove_hook_ != NULL) remove_hook_->::Hekate::Protobuf::Proto::Client::RemoveHookMessage::Clear();
  clear_has_remove_hook();
}
inline const ::Hekate::Protobuf::Proto::Client::RemoveHookMessage& ClientToHekateMessage::remove_hook() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.remove_hook)
  return remove_hook_ != NULL ? *remove_hook_ : *default_instance_->remove_hook_;
}
inline ::Hekate::Protobuf::Proto::Client::RemoveHookMessage* ClientToHekateMessage::mutable_remove_hook() {
  set_has_remove_hook();
  if (remove_hook_ == NULL) {
    remove_hook_ = new ::Hekate::Protobuf::Proto::Client::RemoveHookMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.remove_hook)
  return remove_hook_;
}
inline ::Hekate::Protobuf::Proto::Client::RemoveHookMessage* ClientToHekateMessage::release_remove_hook() {
  clear_has_remove_hook();
  ::Hekate::Protobuf::Proto::Client::RemoveHookMessage* temp = remove_hook_;
  remove_hook_ = NULL;
  return temp;
}
inline void ClientToHekateMessage::set_allocated_remove_hook(::Hekate::Protobuf::Proto::Client::RemoveHookMessage* remove_hook) {
  delete remove_hook_;
  remove_hook_ = remove_hook;
  if (remove_hook) {
    set_has_remove_hook();
  } else {
    clear_has_remove_hook();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.remove_hook)
}

// optional .Hekate.Protobuf.Proto.Client.AddFilterMessage add_filter = 4;
inline bool ClientToHekateMessage::has_add_filter() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ClientToHekateMessage::set_has_add_filter() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ClientToHekateMessage::clear_has_add_filter() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ClientToHekateMessage::clear_add_filter() {
  if (add_filter_ != NULL) add_filter_->::Hekate::Protobuf::Proto::Client::AddFilterMessage::Clear();
  clear_has_add_filter();
}
inline const ::Hekate::Protobuf::Proto::Client::AddFilterMessage& ClientToHekateMessage::add_filter() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.add_filter)
  return add_filter_ != NULL ? *add_filter_ : *default_instance_->add_filter_;
}
inline ::Hekate::Protobuf::Proto::Client::AddFilterMessage* ClientToHekateMessage::mutable_add_filter() {
  set_has_add_filter();
  if (add_filter_ == NULL) {
    add_filter_ = new ::Hekate::Protobuf::Proto::Client::AddFilterMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.add_filter)
  return add_filter_;
}
inline ::Hekate::Protobuf::Proto::Client::AddFilterMessage* ClientToHekateMessage::release_add_filter() {
  clear_has_add_filter();
  ::Hekate::Protobuf::Proto::Client::AddFilterMessage* temp = add_filter_;
  add_filter_ = NULL;
  return temp;
}
inline void ClientToHekateMessage::set_allocated_add_filter(::Hekate::Protobuf::Proto::Client::AddFilterMessage* add_filter) {
  delete add_filter_;
  add_filter_ = add_filter;
  if (add_filter) {
    set_has_add_filter();
  } else {
    clear_has_add_filter();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.add_filter)
}

// optional .Hekate.Protobuf.Proto.Client.RemoveFilterMessage remove_filter = 5;
inline bool ClientToHekateMessage::has_remove_filter() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ClientToHekateMessage::set_has_remove_filter() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ClientToHekateMessage::clear_has_remove_filter() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ClientToHekateMessage::clear_remove_filter() {
  if (remove_filter_ != NULL) remove_filter_->::Hekate::Protobuf::Proto::Client::RemoveFilterMessage::Clear();
  clear_has_remove_filter();
}
inline const ::Hekate::Protobuf::Proto::Client::RemoveFilterMessage& ClientToHekateMessage::remove_filter() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.remove_filter)
  return remove_filter_ != NULL ? *remove_filter_ : *default_instance_->remove_filter_;
}
inline ::Hekate::Protobuf::Proto::Client::RemoveFilterMessage* ClientToHekateMessage::mutable_remove_filter() {
  set_has_remove_filter();
  if (remove_filter_ == NULL) {
    remove_filter_ = new ::Hekate::Protobuf::Proto::Client::RemoveFilterMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.remove_filter)
  return remove_filter_;
}
inline ::Hekate::Protobuf::Proto::Client::RemoveFilterMessage* ClientToHekateMessage::release_remove_filter() {
  clear_has_remove_filter();
  ::Hekate::Protobuf::Proto::Client::RemoveFilterMessage* temp = remove_filter_;
  remove_filter_ = NULL;
  return temp;
}
inline void ClientToHekateMessage::set_allocated_remove_filter(::Hekate::Protobuf::Proto::Client::RemoveFilterMessage* remove_filter) {
  delete remove_filter_;
  remove_filter_ = remove_filter;
  if (remove_filter) {
    set_has_remove_filter();
  } else {
    clear_has_remove_filter();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.remove_filter)
}

// optional .Hekate.Protobuf.Proto.Client.ReplayMessage replay = 6;
inline bool ClientToHekateMessage::has_replay() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ClientToHekateMessage::set_has_replay() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ClientToHekateMessage::clear_has_replay() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ClientToHekateMessage::clear_replay() {
  if (replay_ != NULL) replay_->::Hekate::Protobuf::Proto::Client::ReplayMessage::Clear();
  clear_has_replay();
}
inline const ::Hekate::Protobuf::Proto::Client::ReplayMessage& ClientToHekateMessage::replay() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.replay)
  return replay_ != NULL ? *replay_ : *default_instance_->replay_;
}
inline ::Hekate::Protobuf::Proto::Client::ReplayMessage* ClientToHekateMessage::mutable_replay() {
  set_has_replay();
  if (replay_ == NULL) {
    replay_ = new ::Hekate::Protobuf::Proto::Client::ReplayMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.replay)
  return replay_;
}
inline ::Hekate::Protobuf::Proto::Client::ReplayMessage* ClientToHekateMessage::release_replay() {
  clear_has_replay();
  ::Hekate::Protobuf::Proto::Client::ReplayMessage* temp = replay_;
  replay_ = NULL;
  return temp;
}
inline void ClientToHekateMessage::set_allocated_replay(::Hekate::Protobuf::Proto::Client::ReplayMessage* replay) {
  delete replay_;
  replay_ = replay;
  if (replay) {
    set_has_replay();
  } else {
    clear_has_replay();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.replay)
}

// optional bool continue = 7;
inline bool ClientToHekateMessage::has_continue_() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ClientToHekateMessage::set_has_continue_() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ClientToHekateMessage::clear_has_continue_() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ClientToHekateMessage::clear_continue_() {
  continue__ = false;
  clear_has_continue_();
}
inline bool ClientToHekateMessage::continue_() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.continue)
  return continue__;
}
inline void ClientToHekateMessage::set_continue_(bool value) {
  set_has_continue_();
  continue__ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.ClientToHekateMessage.continue)
}

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

// HekateClientMessage

// required .Hekate.Protobuf.Proto.Client.ClientToHekateMessage clientMessage = 1;
inline bool HekateClientMessage::has_clientmessage() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HekateClientMessage::set_has_clientmessage() {
  _has_bits_[0] |= 0x00000001u;
}
inline void HekateClientMessage::clear_has_clientmessage() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void HekateClientMessage::clear_clientmessage() {
  if (clientmessage_ != NULL) clientmessage_->::Hekate::Protobuf::Proto::Client::ClientToHekateMessage::Clear();
  clear_has_clientmessage();
}
inline const ::Hekate::Protobuf::Proto::Client::ClientToHekateMessage& HekateClientMessage::clientmessage() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.HekateClientMessage.clientMessage)
  return clientmessage_ != NULL ? *clientmessage_ : *default_instance_->clientmessage_;
}
inline ::Hekate::Protobuf::Proto::Client::ClientToHekateMessage* HekateClientMessage::mutable_clientmessage() {
  set_has_clientmessage();
  if (clientmessage_ == NULL) {
    clientmessage_ = new ::Hekate::Protobuf::Proto::Client::ClientToHekateMessage;
  }
  // @@protoc_insertion_point(field_mutable:Hekate.Protobuf.Proto.Client.HekateClientMessage.clientMessage)
  return clientmessage_;
}
inline ::Hekate::Protobuf::Proto::Client::ClientToHekateMessage* HekateClientMessage::release_clientmessage() {
  clear_has_clientmessage();
  ::Hekate::Protobuf::Proto::Client::ClientToHekateMessage* temp = clientmessage_;
  clientmessage_ = NULL;
  return temp;
}
inline void HekateClientMessage::set_allocated_clientmessage(::Hekate::Protobuf::Proto::Client::ClientToHekateMessage* clientmessage) {
  delete clientmessage_;
  clientmessage_ = clientmessage;
  if (clientmessage) {
    set_has_clientmessage();
  } else {
    clear_has_clientmessage();
  }
  // @@protoc_insertion_point(field_set_allocated:Hekate.Protobuf.Proto.Client.HekateClientMessage.clientMessage)
}

// optional int32 debug_response_id = 2;
inline bool HekateClientMessage::has_debug_response_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void HekateClientMessage::set_has_debug_response_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void HekateClientMessage::clear_has_debug_response_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void HekateClientMessage::clear_debug_response_id() {
  debug_response_id_ = 0;
  clear_has_debug_response_id();
}
inline ::google::protobuf::int32 HekateClientMessage::debug_response_id() const {
  // @@protoc_insertion_point(field_get:Hekate.Protobuf.Proto.Client.HekateClientMessage.debug_response_id)
  return debug_response_id_;
}
inline void HekateClientMessage::set_debug_response_id(::google::protobuf::int32 value) {
  set_has_debug_response_id();
  debug_response_id_ = value;
  // @@protoc_insertion_point(field_set:Hekate.Protobuf.Proto.Client.HekateClientMessage.debug_response_id)
}

#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace Client
}  // namespace Proto
}  // namespace Protobuf
}  // namespace Hekate

#ifndef SWIG
namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::Hekate::Protobuf::Proto::Client::FilterType> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Hekate::Protobuf::Proto::Client::FilterType>() {
  return ::Hekate::Protobuf::Proto::Client::FilterType_descriptor();
}
template <> struct is_proto_enum< ::Hekate::Protobuf::Proto::Client::LengthType> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Hekate::Protobuf::Proto::Client::LengthType>() {
  return ::Hekate::Protobuf::Proto::Client::LengthType_descriptor();
}
template <> struct is_proto_enum< ::Hekate::Protobuf::Proto::Client::MessageType> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::Hekate::Protobuf::Proto::Client::MessageType>() {
  return ::Hekate::Protobuf::Proto::Client::MessageType_descriptor();
}

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

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_HekateClientProto_2eproto__INCLUDED
