types/v2/cpp/hub.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_hub_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_hub_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3015000
#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 3015008 < 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/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "result.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_hub_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_hub_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[5]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_hub_2eproto;
::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_hub_2eproto_metadata_getter(int index);
namespace pb {
class BoolValue;
struct BoolValueDefaultTypeInternal;
extern BoolValueDefaultTypeInternal _BoolValue_default_instance_;
class InvertibleField;
struct InvertibleFieldDefaultTypeInternal;
extern InvertibleFieldDefaultTypeInternal _InvertibleField_default_instance_;
class RangeField;
struct RangeFieldDefaultTypeInternal;
extern RangeFieldDefaultTypeInternal _RangeField_default_instance_;
class SearchRequest;
struct SearchRequestDefaultTypeInternal;
extern SearchRequestDefaultTypeInternal _SearchRequest_default_instance_;
class UInt32Value;
struct UInt32ValueDefaultTypeInternal;
extern UInt32ValueDefaultTypeInternal _UInt32Value_default_instance_;
}  // namespace pb
PROTOBUF_NAMESPACE_OPEN
template<> ::pb::BoolValue* Arena::CreateMaybeMessage<::pb::BoolValue>(Arena*);
template<> ::pb::InvertibleField* Arena::CreateMaybeMessage<::pb::InvertibleField>(Arena*);
template<> ::pb::RangeField* Arena::CreateMaybeMessage<::pb::RangeField>(Arena*);
template<> ::pb::SearchRequest* Arena::CreateMaybeMessage<::pb::SearchRequest>(Arena*);
template<> ::pb::UInt32Value* Arena::CreateMaybeMessage<::pb::UInt32Value>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace pb {

enum RangeField_Op : int {
  RangeField_Op_EQ = 0,
  RangeField_Op_LTE = 1,
  RangeField_Op_GTE = 2,
  RangeField_Op_LT = 3,
  RangeField_Op_GT = 4,
  RangeField_Op_RangeField_Op_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  RangeField_Op_RangeField_Op_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool RangeField_Op_IsValid(int value);
constexpr RangeField_Op RangeField_Op_Op_MIN = RangeField_Op_EQ;
constexpr RangeField_Op RangeField_Op_Op_MAX = RangeField_Op_GT;
constexpr int RangeField_Op_Op_ARRAYSIZE = RangeField_Op_Op_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RangeField_Op_descriptor();
template<typename T>
inline const std::string& RangeField_Op_Name(T enum_t_value) {
  static_assert(::std::is_same<T, RangeField_Op>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function RangeField_Op_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    RangeField_Op_descriptor(), enum_t_value);
}
inline bool RangeField_Op_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RangeField_Op* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RangeField_Op>(
    RangeField_Op_descriptor(), name, value);
}
// ===================================================================

class InvertibleField PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.InvertibleField) */ {
 public:
  inline InvertibleField() : InvertibleField(nullptr) {}
  virtual ~InvertibleField();
  explicit constexpr InvertibleField(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  InvertibleField(const InvertibleField& from);
  InvertibleField(InvertibleField&& from) noexcept
    : InvertibleField() {
    *this = ::std::move(from);
  }

  inline InvertibleField& operator=(const InvertibleField& from) {
    CopyFrom(from);
    return *this;
  }
  inline InvertibleField& operator=(InvertibleField&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const InvertibleField& default_instance() {
    return *internal_default_instance();
  }
  static inline const InvertibleField* internal_default_instance() {
    return reinterpret_cast<const InvertibleField*>(
               &_InvertibleField_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(InvertibleField& a, InvertibleField& b) {
    a.Swap(&b);
  }
  inline void Swap(InvertibleField* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(InvertibleField* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline InvertibleField* New() const final {
    return CreateMaybeMessage<InvertibleField>(nullptr);
  }

  InvertibleField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<InvertibleField>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const InvertibleField& from);
  void MergeFrom(const InvertibleField& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(InvertibleField* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.InvertibleField";
  }
  protected:
  explicit InvertibleField(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_hub_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

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

  enum : int {
    kValueFieldNumber = 2,
    kInvertFieldNumber = 1,
  };
  // repeated string value = 2;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  const std::string& value(int index) const;
  std::string* mutable_value(int index);
  void set_value(int index, const std::string& value);
  void set_value(int index, std::string&& value);
  void set_value(int index, const char* value);
  void set_value(int index, const char* value, size_t size);
  std::string* add_value();
  void add_value(const std::string& value);
  void add_value(std::string&& value);
  void add_value(const char* value);
  void add_value(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_value();
  private:
  const std::string& _internal_value(int index) const;
  std::string* _internal_add_value();
  public:

  // bool invert = 1;
  void clear_invert();
  bool invert() const;
  void set_invert(bool value);
  private:
  bool _internal_invert() const;
  void _internal_set_invert(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pb.InvertibleField)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> value_;
  bool invert_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_hub_2eproto;
};
// -------------------------------------------------------------------

class BoolValue PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.BoolValue) */ {
 public:
  inline BoolValue() : BoolValue(nullptr) {}
  virtual ~BoolValue();
  explicit constexpr BoolValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  BoolValue(const BoolValue& from);
  BoolValue(BoolValue&& from) noexcept
    : BoolValue() {
    *this = ::std::move(from);
  }

  inline BoolValue& operator=(const BoolValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline BoolValue& operator=(BoolValue&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const BoolValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const BoolValue* internal_default_instance() {
    return reinterpret_cast<const BoolValue*>(
               &_BoolValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(BoolValue& a, BoolValue& b) {
    a.Swap(&b);
  }
  inline void Swap(BoolValue* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(BoolValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline BoolValue* New() const final {
    return CreateMaybeMessage<BoolValue>(nullptr);
  }

  BoolValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<BoolValue>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const BoolValue& from);
  void MergeFrom(const BoolValue& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(BoolValue* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.BoolValue";
  }
  protected:
  explicit BoolValue(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_hub_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

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

  enum : int {
    kValueFieldNumber = 1,
  };
  // bool value = 1;
  void clear_value();
  bool value() const;
  void set_value(bool value);
  private:
  bool _internal_value() const;
  void _internal_set_value(bool value);
  public:

  // @@protoc_insertion_point(class_scope:pb.BoolValue)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  bool value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_hub_2eproto;
};
// -------------------------------------------------------------------

class UInt32Value PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.UInt32Value) */ {
 public:
  inline UInt32Value() : UInt32Value(nullptr) {}
  virtual ~UInt32Value();
  explicit constexpr UInt32Value(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  UInt32Value(const UInt32Value& from);
  UInt32Value(UInt32Value&& from) noexcept
    : UInt32Value() {
    *this = ::std::move(from);
  }

  inline UInt32Value& operator=(const UInt32Value& from) {
    CopyFrom(from);
    return *this;
  }
  inline UInt32Value& operator=(UInt32Value&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const UInt32Value& default_instance() {
    return *internal_default_instance();
  }
  static inline const UInt32Value* internal_default_instance() {
    return reinterpret_cast<const UInt32Value*>(
               &_UInt32Value_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(UInt32Value& a, UInt32Value& b) {
    a.Swap(&b);
  }
  inline void Swap(UInt32Value* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(UInt32Value* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline UInt32Value* New() const final {
    return CreateMaybeMessage<UInt32Value>(nullptr);
  }

  UInt32Value* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<UInt32Value>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const UInt32Value& from);
  void MergeFrom(const UInt32Value& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(UInt32Value* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.UInt32Value";
  }
  protected:
  explicit UInt32Value(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_hub_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

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

  enum : int {
    kValueFieldNumber = 1,
  };
  // uint32 value = 1;
  void clear_value();
  ::PROTOBUF_NAMESPACE_ID::uint32 value() const;
  void set_value(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_value() const;
  void _internal_set_value(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:pb.UInt32Value)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::uint32 value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_hub_2eproto;
};
// -------------------------------------------------------------------

class RangeField PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.RangeField) */ {
 public:
  inline RangeField() : RangeField(nullptr) {}
  virtual ~RangeField();
  explicit constexpr RangeField(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RangeField(const RangeField& from);
  RangeField(RangeField&& from) noexcept
    : RangeField() {
    *this = ::std::move(from);
  }

  inline RangeField& operator=(const RangeField& from) {
    CopyFrom(from);
    return *this;
  }
  inline RangeField& operator=(RangeField&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const RangeField& default_instance() {
    return *internal_default_instance();
  }
  static inline const RangeField* internal_default_instance() {
    return reinterpret_cast<const RangeField*>(
               &_RangeField_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(RangeField& a, RangeField& b) {
    a.Swap(&b);
  }
  inline void Swap(RangeField* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RangeField* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline RangeField* New() const final {
    return CreateMaybeMessage<RangeField>(nullptr);
  }

  RangeField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RangeField>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const RangeField& from);
  void MergeFrom(const RangeField& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RangeField* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.RangeField";
  }
  protected:
  explicit RangeField(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_hub_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

  typedef RangeField_Op Op;
  static constexpr Op EQ =
    RangeField_Op_EQ;
  static constexpr Op LTE =
    RangeField_Op_LTE;
  static constexpr Op GTE =
    RangeField_Op_GTE;
  static constexpr Op LT =
    RangeField_Op_LT;
  static constexpr Op GT =
    RangeField_Op_GT;
  static inline bool Op_IsValid(int value) {
    return RangeField_Op_IsValid(value);
  }
  static constexpr Op Op_MIN =
    RangeField_Op_Op_MIN;
  static constexpr Op Op_MAX =
    RangeField_Op_Op_MAX;
  static constexpr int Op_ARRAYSIZE =
    RangeField_Op_Op_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Op_descriptor() {
    return RangeField_Op_descriptor();
  }
  template<typename T>
  static inline const std::string& Op_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Op>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Op_Name.");
    return RangeField_Op_Name(enum_t_value);
  }
  static inline bool Op_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Op* value) {
    return RangeField_Op_Parse(name, value);
  }

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

  enum : int {
    kValueFieldNumber = 2,
    kOpFieldNumber = 1,
  };
  // repeated string value = 2;
  int value_size() const;
  private:
  int _internal_value_size() const;
  public:
  void clear_value();
  const std::string& value(int index) const;
  std::string* mutable_value(int index);
  void set_value(int index, const std::string& value);
  void set_value(int index, std::string&& value);
  void set_value(int index, const char* value);
  void set_value(int index, const char* value, size_t size);
  std::string* add_value();
  void add_value(const std::string& value);
  void add_value(std::string&& value);
  void add_value(const char* value);
  void add_value(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& value() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_value();
  private:
  const std::string& _internal_value(int index) const;
  std::string* _internal_add_value();
  public:

  // .pb.RangeField.Op op = 1;
  void clear_op();
  ::pb::RangeField_Op op() const;
  void set_op(::pb::RangeField_Op value);
  private:
  ::pb::RangeField_Op _internal_op() const;
  void _internal_set_op(::pb::RangeField_Op value);
  public:

  // @@protoc_insertion_point(class_scope:pb.RangeField)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> value_;
  int op_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_hub_2eproto;
};
// -------------------------------------------------------------------

class SearchRequest PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:pb.SearchRequest) */ {
 public:
  inline SearchRequest() : SearchRequest(nullptr) {}
  virtual ~SearchRequest();
  explicit constexpr SearchRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  SearchRequest(const SearchRequest& from);
  SearchRequest(SearchRequest&& from) noexcept
    : SearchRequest() {
    *this = ::std::move(from);
  }

  inline SearchRequest& operator=(const SearchRequest& from) {
    CopyFrom(from);
    return *this;
  }
  inline SearchRequest& operator=(SearchRequest&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const SearchRequest& default_instance() {
    return *internal_default_instance();
  }
  static inline const SearchRequest* internal_default_instance() {
    return reinterpret_cast<const SearchRequest*>(
               &_SearchRequest_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(SearchRequest& a, SearchRequest& b) {
    a.Swap(&b);
  }
  inline void Swap(SearchRequest* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SearchRequest* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

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

  inline SearchRequest* New() const final {
    return CreateMaybeMessage<SearchRequest>(nullptr);
  }

  SearchRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SearchRequest>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SearchRequest& from);
  void MergeFrom(const SearchRequest& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(SearchRequest* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.SearchRequest";
  }
  protected:
  explicit SearchRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    return ::descriptor_table_hub_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

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

  enum : int {
    kOrderByFieldNumber = 5,
    kClaimTypeFieldNumber = 25,
    kStreamTypeFieldNumber = 27,
    kMediaTypeFieldNumber = 28,
    kAnyTagsFieldNumber = 49,
    kAllTagsFieldNumber = 50,
    kNotTagsFieldNumber = 51,
    kAnyLanguagesFieldNumber = 55,
    kAllLanguagesFieldNumber = 56,
    kTextFieldNumber = 3,
    kLastTakeOverHeightFieldNumber = 8,
    kNameFieldNumber = 9,
    kNormalizedNameFieldNumber = 10,
    kShortUrlFieldNumber = 20,
    kCanonicalUrlFieldNumber = 21,
    kTitleFieldNumber = 22,
    kAuthorFieldNumber = 23,
    kDescriptionFieldNumber = 24,
    kFeeCurrencyFieldNumber = 30,
    kRepostedClaimIdFieldNumber = 32,
    kClaimsInChannelFieldNumber = 34,
    kTxIdFieldNumber = 43,
    kSignatureFieldNumber = 45,
    kSignatureDigestFieldNumber = 46,
    kPublicKeyBytesFieldNumber = 47,
    kPublicKeyIdFieldNumber = 48,
    kClaimIdFieldNumber = 1,
    kChannelIdFieldNumber = 2,
    kTxPositionFieldNumber = 11,
    kAmountFieldNumber = 12,
    kTimestampFieldNumber = 13,
    kCreationTimestampFieldNumber = 14,
    kHeightFieldNumber = 15,
    kCreationHeightFieldNumber = 16,
    kActivationHeightFieldNumber = 17,
    kExpirationHeightFieldNumber = 18,
    kReleaseTimeFieldNumber = 19,
    kRepostCountFieldNumber = 26,
    kFeeAmountFieldNumber = 29,
    kDurationFieldNumber = 31,
    kCensorTypeFieldNumber = 33,
    kChannelJoinFieldNumber = 35,
    kIsSignatureValidFieldNumber = 36,
    kEffectiveAmountFieldNumber = 37,
    kSupportAmountFieldNumber = 38,
    kTrendingScoreFieldNumber = 39,
    kTxNoutFieldNumber = 44,
    kHasSourceFieldNumber = 53,
    kLimitFieldNumber = 4,
    kOffsetFieldNumber = 6,
    kIsControllingFieldNumber = 7,
    kHasChannelSignatureFieldNumber = 52,
    kRemoveDuplicatesFieldNumber = 57,
    kNoTotalsFieldNumber = 58,
    kLimitClaimsPerChannelFieldNumber = 54,
  };
  // repeated string order_by = 5;
  int order_by_size() const;
  private:
  int _internal_order_by_size() const;
  public:
  void clear_order_by();
  const std::string& order_by(int index) const;
  std::string* mutable_order_by(int index);
  void set_order_by(int index, const std::string& value);
  void set_order_by(int index, std::string&& value);
  void set_order_by(int index, const char* value);
  void set_order_by(int index, const char* value, size_t size);
  std::string* add_order_by();
  void add_order_by(const std::string& value);
  void add_order_by(std::string&& value);
  void add_order_by(const char* value);
  void add_order_by(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& order_by() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_order_by();
  private:
  const std::string& _internal_order_by(int index) const;
  std::string* _internal_add_order_by();
  public:

  // repeated string claim_type = 25;
  int claim_type_size() const;
  private:
  int _internal_claim_type_size() const;
  public:
  void clear_claim_type();
  const std::string& claim_type(int index) const;
  std::string* mutable_claim_type(int index);
  void set_claim_type(int index, const std::string& value);
  void set_claim_type(int index, std::string&& value);
  void set_claim_type(int index, const char* value);
  void set_claim_type(int index, const char* value, size_t size);
  std::string* add_claim_type();
  void add_claim_type(const std::string& value);
  void add_claim_type(std::string&& value);
  void add_claim_type(const char* value);
  void add_claim_type(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& claim_type() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_claim_type();
  private:
  const std::string& _internal_claim_type(int index) const;
  std::string* _internal_add_claim_type();
  public:

  // repeated string stream_type = 27;
  int stream_type_size() const;
  private:
  int _internal_stream_type_size() const;
  public:
  void clear_stream_type();
  const std::string& stream_type(int index) const;
  std::string* mutable_stream_type(int index);
  void set_stream_type(int index, const std::string& value);
  void set_stream_type(int index, std::string&& value);
  void set_stream_type(int index, const char* value);
  void set_stream_type(int index, const char* value, size_t size);
  std::string* add_stream_type();
  void add_stream_type(const std::string& value);
  void add_stream_type(std::string&& value);
  void add_stream_type(const char* value);
  void add_stream_type(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& stream_type() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_stream_type();
  private:
  const std::string& _internal_stream_type(int index) const;
  std::string* _internal_add_stream_type();
  public:

  // repeated string media_type = 28;
  int media_type_size() const;
  private:
  int _internal_media_type_size() const;
  public:
  void clear_media_type();
  const std::string& media_type(int index) const;
  std::string* mutable_media_type(int index);
  void set_media_type(int index, const std::string& value);
  void set_media_type(int index, std::string&& value);
  void set_media_type(int index, const char* value);
  void set_media_type(int index, const char* value, size_t size);
  std::string* add_media_type();
  void add_media_type(const std::string& value);
  void add_media_type(std::string&& value);
  void add_media_type(const char* value);
  void add_media_type(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& media_type() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_media_type();
  private:
  const std::string& _internal_media_type(int index) const;
  std::string* _internal_add_media_type();
  public:

  // repeated string any_tags = 49;
  int any_tags_size() const;
  private:
  int _internal_any_tags_size() const;
  public:
  void clear_any_tags();
  const std::string& any_tags(int index) const;
  std::string* mutable_any_tags(int index);
  void set_any_tags(int index, const std::string& value);
  void set_any_tags(int index, std::string&& value);
  void set_any_tags(int index, const char* value);
  void set_any_tags(int index, const char* value, size_t size);
  std::string* add_any_tags();
  void add_any_tags(const std::string& value);
  void add_any_tags(std::string&& value);
  void add_any_tags(const char* value);
  void add_any_tags(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& any_tags() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_any_tags();
  private:
  const std::string& _internal_any_tags(int index) const;
  std::string* _internal_add_any_tags();
  public:

  // repeated string all_tags = 50;
  int all_tags_size() const;
  private:
  int _internal_all_tags_size() const;
  public:
  void clear_all_tags();
  const std::string& all_tags(int index) const;
  std::string* mutable_all_tags(int index);
  void set_all_tags(int index, const std::string& value);
  void set_all_tags(int index, std::string&& value);
  void set_all_tags(int index, const char* value);
  void set_all_tags(int index, const char* value, size_t size);
  std::string* add_all_tags();
  void add_all_tags(const std::string& value);
  void add_all_tags(std::string&& value);
  void add_all_tags(const char* value);
  void add_all_tags(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& all_tags() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_all_tags();
  private:
  const std::string& _internal_all_tags(int index) const;
  std::string* _internal_add_all_tags();
  public:

  // repeated string not_tags = 51;
  int not_tags_size() const;
  private:
  int _internal_not_tags_size() const;
  public:
  void clear_not_tags();
  const std::string& not_tags(int index) const;
  std::string* mutable_not_tags(int index);
  void set_not_tags(int index, const std::string& value);
  void set_not_tags(int index, std::string&& value);
  void set_not_tags(int index, const char* value);
  void set_not_tags(int index, const char* value, size_t size);
  std::string* add_not_tags();
  void add_not_tags(const std::string& value);
  void add_not_tags(std::string&& value);
  void add_not_tags(const char* value);
  void add_not_tags(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& not_tags() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_not_tags();
  private:
  const std::string& _internal_not_tags(int index) const;
  std::string* _internal_add_not_tags();
  public:

  // repeated string any_languages = 55;
  int any_languages_size() const;
  private:
  int _internal_any_languages_size() const;
  public:
  void clear_any_languages();
  const std::string& any_languages(int index) const;
  std::string* mutable_any_languages(int index);
  void set_any_languages(int index, const std::string& value);
  void set_any_languages(int index, std::string&& value);
  void set_any_languages(int index, const char* value);
  void set_any_languages(int index, const char* value, size_t size);
  std::string* add_any_languages();
  void add_any_languages(const std::string& value);
  void add_any_languages(std::string&& value);
  void add_any_languages(const char* value);
  void add_any_languages(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& any_languages() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_any_languages();
  private:
  const std::string& _internal_any_languages(int index) const;
  std::string* _internal_add_any_languages();
  public:

  // repeated string all_languages = 56;
  int all_languages_size() const;
  private:
  int _internal_all_languages_size() const;
  public:
  void clear_all_languages();
  const std::string& all_languages(int index) const;
  std::string* mutable_all_languages(int index);
  void set_all_languages(int index, const std::string& value);
  void set_all_languages(int index, std::string&& value);
  void set_all_languages(int index, const char* value);
  void set_all_languages(int index, const char* value, size_t size);
  std::string* add_all_languages();
  void add_all_languages(const std::string& value);
  void add_all_languages(std::string&& value);
  void add_all_languages(const char* value);
  void add_all_languages(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& all_languages() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_all_languages();
  private:
  const std::string& _internal_all_languages(int index) const;
  std::string* _internal_add_all_languages();
  public:

  // string text = 3;
  void clear_text();
  const std::string& text() const;
  void set_text(const std::string& value);
  void set_text(std::string&& value);
  void set_text(const char* value);
  void set_text(const char* value, size_t size);
  std::string* mutable_text();
  std::string* release_text();
  void set_allocated_text(std::string* text);
  private:
  const std::string& _internal_text() const;
  void _internal_set_text(const std::string& value);
  std::string* _internal_mutable_text();
  public:

  // string last_take_over_height = 8;
  void clear_last_take_over_height();
  const std::string& last_take_over_height() const;
  void set_last_take_over_height(const std::string& value);
  void set_last_take_over_height(std::string&& value);
  void set_last_take_over_height(const char* value);
  void set_last_take_over_height(const char* value, size_t size);
  std::string* mutable_last_take_over_height();
  std::string* release_last_take_over_height();
  void set_allocated_last_take_over_height(std::string* last_take_over_height);
  private:
  const std::string& _internal_last_take_over_height() const;
  void _internal_set_last_take_over_height(const std::string& value);
  std::string* _internal_mutable_last_take_over_height();
  public:

  // string name = 9;
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(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);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string normalized_name = 10;
  void clear_normalized_name();
  const std::string& normalized_name() const;
  void set_normalized_name(const std::string& value);
  void set_normalized_name(std::string&& value);
  void set_normalized_name(const char* value);
  void set_normalized_name(const char* value, size_t size);
  std::string* mutable_normalized_name();
  std::string* release_normalized_name();
  void set_allocated_normalized_name(std::string* normalized_name);
  private:
  const std::string& _internal_normalized_name() const;
  void _internal_set_normalized_name(const std::string& value);
  std::string* _internal_mutable_normalized_name();
  public:

  // string short_url = 20;
  void clear_short_url();
  const std::string& short_url() const;
  void set_short_url(const std::string& value);
  void set_short_url(std::string&& value);
  void set_short_url(const char* value);
  void set_short_url(const char* value, size_t size);
  std::string* mutable_short_url();
  std::string* release_short_url();
  void set_allocated_short_url(std::string* short_url);
  private:
  const std::string& _internal_short_url() const;
  void _internal_set_short_url(const std::string& value);
  std::string* _internal_mutable_short_url();
  public:

  // string canonical_url = 21;
  void clear_canonical_url();
  const std::string& canonical_url() const;
  void set_canonical_url(const std::string& value);
  void set_canonical_url(std::string&& value);
  void set_canonical_url(const char* value);
  void set_canonical_url(const char* value, size_t size);
  std::string* mutable_canonical_url();
  std::string* release_canonical_url();
  void set_allocated_canonical_url(std::string* canonical_url);
  private:
  const std::string& _internal_canonical_url() const;
  void _internal_set_canonical_url(const std::string& value);
  std::string* _internal_mutable_canonical_url();
  public:

  // string title = 22;
  void clear_title();
  const std::string& title() const;
  void set_title(const std::string& value);
  void set_title(std::string&& value);
  void set_title(const char* value);
  void set_title(const char* value, size_t size);
  std::string* mutable_title();
  std::string* release_title();
  void set_allocated_title(std::string* title);
  private:
  const std::string& _internal_title() const;
  void _internal_set_title(const std::string& value);
  std::string* _internal_mutable_title();
  public:

  // string author = 23;
  void clear_author();
  const std::string& author() const;
  void set_author(const std::string& value);
  void set_author(std::string&& value);
  void set_author(const char* value);
  void set_author(const char* value, size_t size);
  std::string* mutable_author();
  std::string* release_author();
  void set_allocated_author(std::string* author);
  private:
  const std::string& _internal_author() const;
  void _internal_set_author(const std::string& value);
  std::string* _internal_mutable_author();
  public:

  // string description = 24;
  void clear_description();
  const std::string& description() const;
  void set_description(const std::string& value);
  void set_description(std::string&& value);
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  std::string* mutable_description();
  std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // string fee_currency = 30;
  void clear_fee_currency();
  const std::string& fee_currency() const;
  void set_fee_currency(const std::string& value);
  void set_fee_currency(std::string&& value);
  void set_fee_currency(const char* value);
  void set_fee_currency(const char* value, size_t size);
  std::string* mutable_fee_currency();
  std::string* release_fee_currency();
  void set_allocated_fee_currency(std::string* fee_currency);
  private:
  const std::string& _internal_fee_currency() const;
  void _internal_set_fee_currency(const std::string& value);
  std::string* _internal_mutable_fee_currency();
  public:

  // string reposted_claim_id = 32;
  void clear_reposted_claim_id();
  const std::string& reposted_claim_id() const;
  void set_reposted_claim_id(const std::string& value);
  void set_reposted_claim_id(std::string&& value);
  void set_reposted_claim_id(const char* value);
  void set_reposted_claim_id(const char* value, size_t size);
  std::string* mutable_reposted_claim_id();
  std::string* release_reposted_claim_id();
  void set_allocated_reposted_claim_id(std::string* reposted_claim_id);
  private:
  const std::string& _internal_reposted_claim_id() const;
  void _internal_set_reposted_claim_id(const std::string& value);
  std::string* _internal_mutable_reposted_claim_id();
  public:

  // string claims_in_channel = 34;
  void clear_claims_in_channel();
  const std::string& claims_in_channel() const;
  void set_claims_in_channel(const std::string& value);
  void set_claims_in_channel(std::string&& value);
  void set_claims_in_channel(const char* value);
  void set_claims_in_channel(const char* value, size_t size);
  std::string* mutable_claims_in_channel();
  std::string* release_claims_in_channel();
  void set_allocated_claims_in_channel(std::string* claims_in_channel);
  private:
  const std::string& _internal_claims_in_channel() const;
  void _internal_set_claims_in_channel(const std::string& value);
  std::string* _internal_mutable_claims_in_channel();
  public:

  // string tx_id = 43;
  void clear_tx_id();
  const std::string& tx_id() const;
  void set_tx_id(const std::string& value);
  void set_tx_id(std::string&& value);
  void set_tx_id(const char* value);
  void set_tx_id(const char* value, size_t size);
  std::string* mutable_tx_id();
  std::string* release_tx_id();
  void set_allocated_tx_id(std::string* tx_id);
  private:
  const std::string& _internal_tx_id() const;
  void _internal_set_tx_id(const std::string& value);
  std::string* _internal_mutable_tx_id();
  public:

  // string signature = 45;
  void clear_signature();
  const std::string& signature() const;
  void set_signature(const std::string& value);
  void set_signature(std::string&& value);
  void set_signature(const char* value);
  void set_signature(const char* value, size_t size);
  std::string* mutable_signature();
  std::string* release_signature();
  void set_allocated_signature(std::string* signature);
  private:
  const std::string& _internal_signature() const;
  void _internal_set_signature(const std::string& value);
  std::string* _internal_mutable_signature();
  public:

  // string signature_digest = 46;
  void clear_signature_digest();
  const std::string& signature_digest() const;
  void set_signature_digest(const std::string& value);
  void set_signature_digest(std::string&& value);
  void set_signature_digest(const char* value);
  void set_signature_digest(const char* value, size_t size);
  std::string* mutable_signature_digest();
  std::string* release_signature_digest();
  void set_allocated_signature_digest(std::string* signature_digest);
  private:
  const std::string& _internal_signature_digest() const;
  void _internal_set_signature_digest(const std::string& value);
  std::string* _internal_mutable_signature_digest();
  public:

  // string public_key_bytes = 47;
  void clear_public_key_bytes();
  const std::string& public_key_bytes() const;
  void set_public_key_bytes(const std::string& value);
  void set_public_key_bytes(std::string&& value);
  void set_public_key_bytes(const char* value);
  void set_public_key_bytes(const char* value, size_t size);
  std::string* mutable_public_key_bytes();
  std::string* release_public_key_bytes();
  void set_allocated_public_key_bytes(std::string* public_key_bytes);
  private:
  const std::string& _internal_public_key_bytes() const;
  void _internal_set_public_key_bytes(const std::string& value);
  std::string* _internal_mutable_public_key_bytes();
  public:

  // string public_key_id = 48;
  void clear_public_key_id();
  const std::string& public_key_id() const;
  void set_public_key_id(const std::string& value);
  void set_public_key_id(std::string&& value);
  void set_public_key_id(const char* value);
  void set_public_key_id(const char* value, size_t size);
  std::string* mutable_public_key_id();
  std::string* release_public_key_id();
  void set_allocated_public_key_id(std::string* public_key_id);
  private:
  const std::string& _internal_public_key_id() const;
  void _internal_set_public_key_id(const std::string& value);
  std::string* _internal_mutable_public_key_id();
  public:

  // .pb.InvertibleField claim_id = 1;
  bool has_claim_id() const;
  private:
  bool _internal_has_claim_id() const;
  public:
  void clear_claim_id();
  const ::pb::InvertibleField& claim_id() const;
  ::pb::InvertibleField* release_claim_id();
  ::pb::InvertibleField* mutable_claim_id();
  void set_allocated_claim_id(::pb::InvertibleField* claim_id);
  private:
  const ::pb::InvertibleField& _internal_claim_id() const;
  ::pb::InvertibleField* _internal_mutable_claim_id();
  public:
  void unsafe_arena_set_allocated_claim_id(
      ::pb::InvertibleField* claim_id);
  ::pb::InvertibleField* unsafe_arena_release_claim_id();

  // .pb.InvertibleField channel_id = 2;
  bool has_channel_id() const;
  private:
  bool _internal_has_channel_id() const;
  public:
  void clear_channel_id();
  const ::pb::InvertibleField& channel_id() const;
  ::pb::InvertibleField* release_channel_id();
  ::pb::InvertibleField* mutable_channel_id();
  void set_allocated_channel_id(::pb::InvertibleField* channel_id);
  private:
  const ::pb::InvertibleField& _internal_channel_id() const;
  ::pb::InvertibleField* _internal_mutable_channel_id();
  public:
  void unsafe_arena_set_allocated_channel_id(
      ::pb::InvertibleField* channel_id);
  ::pb::InvertibleField* unsafe_arena_release_channel_id();

  // .pb.RangeField tx_position = 11;
  bool has_tx_position() const;
  private:
  bool _internal_has_tx_position() const;
  public:
  void clear_tx_position();
  const ::pb::RangeField& tx_position() const;
  ::pb::RangeField* release_tx_position();
  ::pb::RangeField* mutable_tx_position();
  void set_allocated_tx_position(::pb::RangeField* tx_position);
  private:
  const ::pb::RangeField& _internal_tx_position() const;
  ::pb::RangeField* _internal_mutable_tx_position();
  public:
  void unsafe_arena_set_allocated_tx_position(
      ::pb::RangeField* tx_position);
  ::pb::RangeField* unsafe_arena_release_tx_position();

  // .pb.RangeField amount = 12;
  bool has_amount() const;
  private:
  bool _internal_has_amount() const;
  public:
  void clear_amount();
  const ::pb::RangeField& amount() const;
  ::pb::RangeField* release_amount();
  ::pb::RangeField* mutable_amount();
  void set_allocated_amount(::pb::RangeField* amount);
  private:
  const ::pb::RangeField& _internal_amount() const;
  ::pb::RangeField* _internal_mutable_amount();
  public:
  void unsafe_arena_set_allocated_amount(
      ::pb::RangeField* amount);
  ::pb::RangeField* unsafe_arena_release_amount();

  // .pb.RangeField timestamp = 13;
  bool has_timestamp() const;
  private:
  bool _internal_has_timestamp() const;
  public:
  void clear_timestamp();
  const ::pb::RangeField& timestamp() const;
  ::pb::RangeField* release_timestamp();
  ::pb::RangeField* mutable_timestamp();
  void set_allocated_timestamp(::pb::RangeField* timestamp);
  private:
  const ::pb::RangeField& _internal_timestamp() const;
  ::pb::RangeField* _internal_mutable_timestamp();
  public:
  void unsafe_arena_set_allocated_timestamp(
      ::pb::RangeField* timestamp);
  ::pb::RangeField* unsafe_arena_release_timestamp();

  // .pb.RangeField creation_timestamp = 14;
  bool has_creation_timestamp() const;
  private:
  bool _internal_has_creation_timestamp() const;
  public:
  void clear_creation_timestamp();
  const ::pb::RangeField& creation_timestamp() const;
  ::pb::RangeField* release_creation_timestamp();
  ::pb::RangeField* mutable_creation_timestamp();
  void set_allocated_creation_timestamp(::pb::RangeField* creation_timestamp);
  private:
  const ::pb::RangeField& _internal_creation_timestamp() const;
  ::pb::RangeField* _internal_mutable_creation_timestamp();
  public:
  void unsafe_arena_set_allocated_creation_timestamp(
      ::pb::RangeField* creation_timestamp);
  ::pb::RangeField* unsafe_arena_release_creation_timestamp();

  // .pb.RangeField height = 15;
  bool has_height() const;
  private:
  bool _internal_has_height() const;
  public:
  void clear_height();
  const ::pb::RangeField& height() const;
  ::pb::RangeField* release_height();
  ::pb::RangeField* mutable_height();
  void set_allocated_height(::pb::RangeField* height);
  private:
  const ::pb::RangeField& _internal_height() const;
  ::pb::RangeField* _internal_mutable_height();
  public:
  void unsafe_arena_set_allocated_height(
      ::pb::RangeField* height);
  ::pb::RangeField* unsafe_arena_release_height();

  // .pb.RangeField creation_height = 16;
  bool has_creation_height() const;
  private:
  bool _internal_has_creation_height() const;
  public:
  void clear_creation_height();
  const ::pb::RangeField& creation_height() const;
  ::pb::RangeField* release_creation_height();
  ::pb::RangeField* mutable_creation_height();
  void set_allocated_creation_height(::pb::RangeField* creation_height);
  private:
  const ::pb::RangeField& _internal_creation_height() const;
  ::pb::RangeField* _internal_mutable_creation_height();
  public:
  void unsafe_arena_set_allocated_creation_height(
      ::pb::RangeField* creation_height);
  ::pb::RangeField* unsafe_arena_release_creation_height();

  // .pb.RangeField activation_height = 17;
  bool has_activation_height() const;
  private:
  bool _internal_has_activation_height() const;
  public:
  void clear_activation_height();
  const ::pb::RangeField& activation_height() const;
  ::pb::RangeField* release_activation_height();
  ::pb::RangeField* mutable_activation_height();
  void set_allocated_activation_height(::pb::RangeField* activation_height);
  private:
  const ::pb::RangeField& _internal_activation_height() const;
  ::pb::RangeField* _internal_mutable_activation_height();
  public:
  void unsafe_arena_set_allocated_activation_height(
      ::pb::RangeField* activation_height);
  ::pb::RangeField* unsafe_arena_release_activation_height();

  // .pb.RangeField expiration_height = 18;
  bool has_expiration_height() const;
  private:
  bool _internal_has_expiration_height() const;
  public:
  void clear_expiration_height();
  const ::pb::RangeField& expiration_height() const;
  ::pb::RangeField* release_expiration_height();
  ::pb::RangeField* mutable_expiration_height();
  void set_allocated_expiration_height(::pb::RangeField* expiration_height);
  private:
  const ::pb::RangeField& _internal_expiration_height() const;
  ::pb::RangeField* _internal_mutable_expiration_height();
  public:
  void unsafe_arena_set_allocated_expiration_height(
      ::pb::RangeField* expiration_height);
  ::pb::RangeField* unsafe_arena_release_expiration_height();

  // .pb.RangeField release_time = 19;
  bool has_release_time() const;
  private:
  bool _internal_has_release_time() const;
  public:
  void clear_release_time();
  const ::pb::RangeField& release_time() const;
  ::pb::RangeField* release_release_time();
  ::pb::RangeField* mutable_release_time();
  void set_allocated_release_time(::pb::RangeField* release_time);
  private:
  const ::pb::RangeField& _internal_release_time() const;
  ::pb::RangeField* _internal_mutable_release_time();
  public:
  void unsafe_arena_set_allocated_release_time(
      ::pb::RangeField* release_time);
  ::pb::RangeField* unsafe_arena_release_release_time();

  // .pb.RangeField repost_count = 26;
  bool has_repost_count() const;
  private:
  bool _internal_has_repost_count() const;
  public:
  void clear_repost_count();
  const ::pb::RangeField& repost_count() const;
  ::pb::RangeField* release_repost_count();
  ::pb::RangeField* mutable_repost_count();
  void set_allocated_repost_count(::pb::RangeField* repost_count);
  private:
  const ::pb::RangeField& _internal_repost_count() const;
  ::pb::RangeField* _internal_mutable_repost_count();
  public:
  void unsafe_arena_set_allocated_repost_count(
      ::pb::RangeField* repost_count);
  ::pb::RangeField* unsafe_arena_release_repost_count();

  // .pb.RangeField fee_amount = 29;
  bool has_fee_amount() const;
  private:
  bool _internal_has_fee_amount() const;
  public:
  void clear_fee_amount();
  const ::pb::RangeField& fee_amount() const;
  ::pb::RangeField* release_fee_amount();
  ::pb::RangeField* mutable_fee_amount();
  void set_allocated_fee_amount(::pb::RangeField* fee_amount);
  private:
  const ::pb::RangeField& _internal_fee_amount() const;
  ::pb::RangeField* _internal_mutable_fee_amount();
  public:
  void unsafe_arena_set_allocated_fee_amount(
      ::pb::RangeField* fee_amount);
  ::pb::RangeField* unsafe_arena_release_fee_amount();

  // .pb.RangeField duration = 31;
  bool has_duration() const;
  private:
  bool _internal_has_duration() const;
  public:
  void clear_duration();
  const ::pb::RangeField& duration() const;
  ::pb::RangeField* release_duration();
  ::pb::RangeField* mutable_duration();
  void set_allocated_duration(::pb::RangeField* duration);
  private:
  const ::pb::RangeField& _internal_duration() const;
  ::pb::RangeField* _internal_mutable_duration();
  public:
  void unsafe_arena_set_allocated_duration(
      ::pb::RangeField* duration);
  ::pb::RangeField* unsafe_arena_release_duration();

  // .pb.RangeField censor_type = 33;
  bool has_censor_type() const;
  private:
  bool _internal_has_censor_type() const;
  public:
  void clear_censor_type();
  const ::pb::RangeField& censor_type() const;
  ::pb::RangeField* release_censor_type();
  ::pb::RangeField* mutable_censor_type();
  void set_allocated_censor_type(::pb::RangeField* censor_type);
  private:
  const ::pb::RangeField& _internal_censor_type() const;
  ::pb::RangeField* _internal_mutable_censor_type();
  public:
  void unsafe_arena_set_allocated_censor_type(
      ::pb::RangeField* censor_type);
  ::pb::RangeField* unsafe_arena_release_censor_type();

  // .pb.RangeField channel_join = 35;
  bool has_channel_join() const;
  private:
  bool _internal_has_channel_join() const;
  public:
  void clear_channel_join();
  const ::pb::RangeField& channel_join() const;
  ::pb::RangeField* release_channel_join();
  ::pb::RangeField* mutable_channel_join();
  void set_allocated_channel_join(::pb::RangeField* channel_join);
  private:
  const ::pb::RangeField& _internal_channel_join() const;
  ::pb::RangeField* _internal_mutable_channel_join();
  public:
  void unsafe_arena_set_allocated_channel_join(
      ::pb::RangeField* channel_join);
  ::pb::RangeField* unsafe_arena_release_channel_join();

  // .pb.BoolValue is_signature_valid = 36;
  bool has_is_signature_valid() const;
  private:
  bool _internal_has_is_signature_valid() const;
  public:
  void clear_is_signature_valid();
  const ::pb::BoolValue& is_signature_valid() const;
  ::pb::BoolValue* release_is_signature_valid();
  ::pb::BoolValue* mutable_is_signature_valid();
  void set_allocated_is_signature_valid(::pb::BoolValue* is_signature_valid);
  private:
  const ::pb::BoolValue& _internal_is_signature_valid() const;
  ::pb::BoolValue* _internal_mutable_is_signature_valid();
  public:
  void unsafe_arena_set_allocated_is_signature_valid(
      ::pb::BoolValue* is_signature_valid);
  ::pb::BoolValue* unsafe_arena_release_is_signature_valid();

  // .pb.RangeField effective_amount = 37;
  bool has_effective_amount() const;
  private:
  bool _internal_has_effective_amount() const;
  public:
  void clear_effective_amount();
  const ::pb::RangeField& effective_amount() const;
  ::pb::RangeField* release_effective_amount();
  ::pb::RangeField* mutable_effective_amount();
  void set_allocated_effective_amount(::pb::RangeField* effective_amount);
  private:
  const ::pb::RangeField& _internal_effective_amount() const;
  ::pb::RangeField* _internal_mutable_effective_amount();
  public:
  void unsafe_arena_set_allocated_effective_amount(
      ::pb::RangeField* effective_amount);
  ::pb::RangeField* unsafe_arena_release_effective_amount();

  // .pb.RangeField support_amount = 38;
  bool has_support_amount() const;
  private:
  bool _internal_has_support_amount() const;
  public:
  void clear_support_amount();
  const ::pb::RangeField& support_amount() const;
  ::pb::RangeField* release_support_amount();
  ::pb::RangeField* mutable_support_amount();
  void set_allocated_support_amount(::pb::RangeField* support_amount);
  private:
  const ::pb::RangeField& _internal_support_amount() const;
  ::pb::RangeField* _internal_mutable_support_amount();
  public:
  void unsafe_arena_set_allocated_support_amount(
      ::pb::RangeField* support_amount);
  ::pb::RangeField* unsafe_arena_release_support_amount();

  // .pb.RangeField trending_score = 39;
  bool has_trending_score() const;
  private:
  bool _internal_has_trending_score() const;
  public:
  void clear_trending_score();
  const ::pb::RangeField& trending_score() const;
  ::pb::RangeField* release_trending_score();
  ::pb::RangeField* mutable_trending_score();
  void set_allocated_trending_score(::pb::RangeField* trending_score);
  private:
  const ::pb::RangeField& _internal_trending_score() const;
  ::pb::RangeField* _internal_mutable_trending_score();
  public:
  void unsafe_arena_set_allocated_trending_score(
      ::pb::RangeField* trending_score);
  ::pb::RangeField* unsafe_arena_release_trending_score();

  // .pb.UInt32Value tx_nout = 44;
  bool has_tx_nout() const;
  private:
  bool _internal_has_tx_nout() const;
  public:
  void clear_tx_nout();
  const ::pb::UInt32Value& tx_nout() const;
  ::pb::UInt32Value* release_tx_nout();
  ::pb::UInt32Value* mutable_tx_nout();
  void set_allocated_tx_nout(::pb::UInt32Value* tx_nout);
  private:
  const ::pb::UInt32Value& _internal_tx_nout() const;
  ::pb::UInt32Value* _internal_mutable_tx_nout();
  public:
  void unsafe_arena_set_allocated_tx_nout(
      ::pb::UInt32Value* tx_nout);
  ::pb::UInt32Value* unsafe_arena_release_tx_nout();

  // .pb.BoolValue has_source = 53;
  bool has_has_source() const;
  private:
  bool _internal_has_has_source() const;
  public:
  void clear_has_source();
  const ::pb::BoolValue& has_source() const;
  ::pb::BoolValue* release_has_source();
  ::pb::BoolValue* mutable_has_source();
  void set_allocated_has_source(::pb::BoolValue* has_source);
  private:
  const ::pb::BoolValue& _internal_has_source() const;
  ::pb::BoolValue* _internal_mutable_has_source();
  public:
  void unsafe_arena_set_allocated_has_source(
      ::pb::BoolValue* has_source);
  ::pb::BoolValue* unsafe_arena_release_has_source();

  // uint32 limit = 4;
  void clear_limit();
  ::PROTOBUF_NAMESPACE_ID::uint32 limit() const;
  void set_limit(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_limit() const;
  void _internal_set_limit(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 offset = 6;
  void clear_offset();
  ::PROTOBUF_NAMESPACE_ID::uint32 offset() const;
  void set_offset(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_offset() const;
  void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // bool is_controlling = 7;
  void clear_is_controlling();
  bool is_controlling() const;
  void set_is_controlling(bool value);
  private:
  bool _internal_is_controlling() const;
  void _internal_set_is_controlling(bool value);
  public:

  // bool has_channel_signature = 52;
  void clear_has_channel_signature();
  bool has_channel_signature() const;
  void set_has_channel_signature(bool value);
  private:
  bool _internal_has_channel_signature() const;
  void _internal_set_has_channel_signature(bool value);
  public:

  // bool remove_duplicates = 57;
  void clear_remove_duplicates();
  bool remove_duplicates() const;
  void set_remove_duplicates(bool value);
  private:
  bool _internal_remove_duplicates() const;
  void _internal_set_remove_duplicates(bool value);
  public:

  // bool no_totals = 58;
  void clear_no_totals();
  bool no_totals() const;
  void set_no_totals(bool value);
  private:
  bool _internal_no_totals() const;
  void _internal_set_no_totals(bool value);
  public:

  // uint32 limit_claims_per_channel = 54;
  void clear_limit_claims_per_channel();
  ::PROTOBUF_NAMESPACE_ID::uint32 limit_claims_per_channel() const;
  void set_limit_claims_per_channel(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_limit_claims_per_channel() const;
  void _internal_set_limit_claims_per_channel(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:pb.SearchRequest)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> order_by_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> claim_type_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> stream_type_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> media_type_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> any_tags_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> all_tags_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> not_tags_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> any_languages_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> all_languages_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr last_take_over_height_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr normalized_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr short_url_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr canonical_url_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr title_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr author_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fee_currency_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr reposted_claim_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr claims_in_channel_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tx_id_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_digest_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public_key_bytes_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public_key_id_;
  ::pb::InvertibleField* claim_id_;
  ::pb::InvertibleField* channel_id_;
  ::pb::RangeField* tx_position_;
  ::pb::RangeField* amount_;
  ::pb::RangeField* timestamp_;
  ::pb::RangeField* creation_timestamp_;
  ::pb::RangeField* height_;
  ::pb::RangeField* creation_height_;
  ::pb::RangeField* activation_height_;
  ::pb::RangeField* expiration_height_;
  ::pb::RangeField* release_time_;
  ::pb::RangeField* repost_count_;
  ::pb::RangeField* fee_amount_;
  ::pb::RangeField* duration_;
  ::pb::RangeField* censor_type_;
  ::pb::RangeField* channel_join_;
  ::pb::BoolValue* is_signature_valid_;
  ::pb::RangeField* effective_amount_;
  ::pb::RangeField* support_amount_;
  ::pb::RangeField* trending_score_;
  ::pb::UInt32Value* tx_nout_;
  ::pb::BoolValue* has_source_;
  ::PROTOBUF_NAMESPACE_ID::uint32 limit_;
  ::PROTOBUF_NAMESPACE_ID::uint32 offset_;
  bool is_controlling_;
  bool has_channel_signature_;
  bool remove_duplicates_;
  bool no_totals_;
  ::PROTOBUF_NAMESPACE_ID::uint32 limit_claims_per_channel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_hub_2eproto;
};
// ===================================================================


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

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// InvertibleField

// bool invert = 1;
inline void InvertibleField::clear_invert() {
  invert_ = false;
}
inline bool InvertibleField::_internal_invert() const {
  return invert_;
}
inline bool InvertibleField::invert() const {
  // @@protoc_insertion_point(field_get:pb.InvertibleField.invert)
  return _internal_invert();
}
inline void InvertibleField::_internal_set_invert(bool value) {
  
  invert_ = value;
}
inline void InvertibleField::set_invert(bool value) {
  _internal_set_invert(value);
  // @@protoc_insertion_point(field_set:pb.InvertibleField.invert)
}

// repeated string value = 2;
inline int InvertibleField::_internal_value_size() const {
  return value_.size();
}
inline int InvertibleField::value_size() const {
  return _internal_value_size();
}
inline void InvertibleField::clear_value() {
  value_.Clear();
}
inline std::string* InvertibleField::add_value() {
  // @@protoc_insertion_point(field_add_mutable:pb.InvertibleField.value)
  return _internal_add_value();
}
inline const std::string& InvertibleField::_internal_value(int index) const {
  return value_.Get(index);
}
inline const std::string& InvertibleField::value(int index) const {
  // @@protoc_insertion_point(field_get:pb.InvertibleField.value)
  return _internal_value(index);
}
inline std::string* InvertibleField::mutable_value(int index) {
  // @@protoc_insertion_point(field_mutable:pb.InvertibleField.value)
  return value_.Mutable(index);
}
inline void InvertibleField::set_value(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:pb.InvertibleField.value)
  value_.Mutable(index)->assign(value);
}
inline void InvertibleField::set_value(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:pb.InvertibleField.value)
  value_.Mutable(index)->assign(std::move(value));
}
inline void InvertibleField::set_value(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  value_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:pb.InvertibleField.value)
}
inline void InvertibleField::set_value(int index, const char* value, size_t size) {
  value_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:pb.InvertibleField.value)
}
inline std::string* InvertibleField::_internal_add_value() {
  return value_.Add();
}
inline void InvertibleField::add_value(const std::string& value) {
  value_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:pb.InvertibleField.value)
}
inline void InvertibleField::add_value(std::string&& value) {
  value_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:pb.InvertibleField.value)
}
inline void InvertibleField::add_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  value_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:pb.InvertibleField.value)
}
inline void InvertibleField::add_value(const char* value, size_t size) {
  value_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:pb.InvertibleField.value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
InvertibleField::value() const {
  // @@protoc_insertion_point(field_list:pb.InvertibleField.value)
  return value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
InvertibleField::mutable_value() {
  // @@protoc_insertion_point(field_mutable_list:pb.InvertibleField.value)
  return &value_;
}

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

// BoolValue

// bool value = 1;
inline void BoolValue::clear_value() {
  value_ = false;
}
inline bool BoolValue::_internal_value() const {
  return value_;
}
inline bool BoolValue::value() const {
  // @@protoc_insertion_point(field_get:pb.BoolValue.value)
  return _internal_value();
}
inline void BoolValue::_internal_set_value(bool value) {
  
  value_ = value;
}
inline void BoolValue::set_value(bool value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:pb.BoolValue.value)
}

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

// UInt32Value

// uint32 value = 1;
inline void UInt32Value::clear_value() {
  value_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 UInt32Value::_internal_value() const {
  return value_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 UInt32Value::value() const {
  // @@protoc_insertion_point(field_get:pb.UInt32Value.value)
  return _internal_value();
}
inline void UInt32Value::_internal_set_value(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  value_ = value;
}
inline void UInt32Value::set_value(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_value(value);
  // @@protoc_insertion_point(field_set:pb.UInt32Value.value)
}

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

// RangeField

// .pb.RangeField.Op op = 1;
inline void RangeField::clear_op() {
  op_ = 0;
}
inline ::pb::RangeField_Op RangeField::_internal_op() const {
  return static_cast< ::pb::RangeField_Op >(op_);
}
inline ::pb::RangeField_Op RangeField::op() const {
  // @@protoc_insertion_point(field_get:pb.RangeField.op)
  return _internal_op();
}
inline void RangeField::_internal_set_op(::pb::RangeField_Op value) {
  
  op_ = value;
}
inline void RangeField::set_op(::pb::RangeField_Op value) {
  _internal_set_op(value);
  // @@protoc_insertion_point(field_set:pb.RangeField.op)
}

// repeated string value = 2;
inline int RangeField::_internal_value_size() const {
  return value_.size();
}
inline int RangeField::value_size() const {
  return _internal_value_size();
}
inline void RangeField::clear_value() {
  value_.Clear();
}
inline std::string* RangeField::add_value() {
  // @@protoc_insertion_point(field_add_mutable:pb.RangeField.value)
  return _internal_add_value();
}
inline const std::string& RangeField::_internal_value(int index) const {
  return value_.Get(index);
}
inline const std::string& RangeField::value(int index) const {
  // @@protoc_insertion_point(field_get:pb.RangeField.value)
  return _internal_value(index);
}
inline std::string* RangeField::mutable_value(int index) {
  // @@protoc_insertion_point(field_mutable:pb.RangeField.value)
  return value_.Mutable(index);
}
inline void RangeField::set_value(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:pb.RangeField.value)
  value_.Mutable(index)->assign(value);
}
inline void RangeField::set_value(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:pb.RangeField.value)
  value_.Mutable(index)->assign(std::move(value));
}
inline void RangeField::set_value(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  value_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:pb.RangeField.value)
}
inline void RangeField::set_value(int index, const char* value, size_t size) {
  value_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:pb.RangeField.value)
}
inline std::string* RangeField::_internal_add_value() {
  return value_.Add();
}
inline void RangeField::add_value(const std::string& value) {
  value_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:pb.RangeField.value)
}
inline void RangeField::add_value(std::string&& value) {
  value_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:pb.RangeField.value)
}
inline void RangeField::add_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  value_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:pb.RangeField.value)
}
inline void RangeField::add_value(const char* value, size_t size) {
  value_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:pb.RangeField.value)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
RangeField::value() const {
  // @@protoc_insertion_point(field_list:pb.RangeField.value)
  return value_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
RangeField::mutable_value() {
  // @@protoc_insertion_point(field_mutable_list:pb.RangeField.value)
  return &value_;
}

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

// SearchRequest

// .pb.InvertibleField claim_id = 1;
inline bool SearchRequest::_internal_has_claim_id() const {
  return this != internal_default_instance() && claim_id_ != nullptr;
}
inline bool SearchRequest::has_claim_id() const {
  return _internal_has_claim_id();
}
inline void SearchRequest::clear_claim_id() {
  if (GetArena() == nullptr && claim_id_ != nullptr) {
    delete claim_id_;
  }
  claim_id_ = nullptr;
}
inline const ::pb::InvertibleField& SearchRequest::_internal_claim_id() const {
  const ::pb::InvertibleField* p = claim_id_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::InvertibleField&>(
      ::pb::_InvertibleField_default_instance_);
}
inline const ::pb::InvertibleField& SearchRequest::claim_id() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.claim_id)
  return _internal_claim_id();
}
inline void SearchRequest::unsafe_arena_set_allocated_claim_id(
    ::pb::InvertibleField* claim_id) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(claim_id_);
  }
  claim_id_ = claim_id;
  if (claim_id) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.claim_id)
}
inline ::pb::InvertibleField* SearchRequest::release_claim_id() {
  
  ::pb::InvertibleField* temp = claim_id_;
  claim_id_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::InvertibleField* SearchRequest::unsafe_arena_release_claim_id() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.claim_id)
  
  ::pb::InvertibleField* temp = claim_id_;
  claim_id_ = nullptr;
  return temp;
}
inline ::pb::InvertibleField* SearchRequest::_internal_mutable_claim_id() {
  
  if (claim_id_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::InvertibleField>(GetArena());
    claim_id_ = p;
  }
  return claim_id_;
}
inline ::pb::InvertibleField* SearchRequest::mutable_claim_id() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.claim_id)
  return _internal_mutable_claim_id();
}
inline void SearchRequest::set_allocated_claim_id(::pb::InvertibleField* claim_id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete claim_id_;
  }
  if (claim_id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(claim_id);
    if (message_arena != submessage_arena) {
      claim_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, claim_id, submessage_arena);
    }
    
  } else {
    
  }
  claim_id_ = claim_id;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.claim_id)
}

// .pb.InvertibleField channel_id = 2;
inline bool SearchRequest::_internal_has_channel_id() const {
  return this != internal_default_instance() && channel_id_ != nullptr;
}
inline bool SearchRequest::has_channel_id() const {
  return _internal_has_channel_id();
}
inline void SearchRequest::clear_channel_id() {
  if (GetArena() == nullptr && channel_id_ != nullptr) {
    delete channel_id_;
  }
  channel_id_ = nullptr;
}
inline const ::pb::InvertibleField& SearchRequest::_internal_channel_id() const {
  const ::pb::InvertibleField* p = channel_id_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::InvertibleField&>(
      ::pb::_InvertibleField_default_instance_);
}
inline const ::pb::InvertibleField& SearchRequest::channel_id() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.channel_id)
  return _internal_channel_id();
}
inline void SearchRequest::unsafe_arena_set_allocated_channel_id(
    ::pb::InvertibleField* channel_id) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(channel_id_);
  }
  channel_id_ = channel_id;
  if (channel_id) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.channel_id)
}
inline ::pb::InvertibleField* SearchRequest::release_channel_id() {
  
  ::pb::InvertibleField* temp = channel_id_;
  channel_id_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::InvertibleField* SearchRequest::unsafe_arena_release_channel_id() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.channel_id)
  
  ::pb::InvertibleField* temp = channel_id_;
  channel_id_ = nullptr;
  return temp;
}
inline ::pb::InvertibleField* SearchRequest::_internal_mutable_channel_id() {
  
  if (channel_id_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::InvertibleField>(GetArena());
    channel_id_ = p;
  }
  return channel_id_;
}
inline ::pb::InvertibleField* SearchRequest::mutable_channel_id() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.channel_id)
  return _internal_mutable_channel_id();
}
inline void SearchRequest::set_allocated_channel_id(::pb::InvertibleField* channel_id) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete channel_id_;
  }
  if (channel_id) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(channel_id);
    if (message_arena != submessage_arena) {
      channel_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, channel_id, submessage_arena);
    }
    
  } else {
    
  }
  channel_id_ = channel_id;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.channel_id)
}

// string text = 3;
inline void SearchRequest::clear_text() {
  text_.ClearToEmpty();
}
inline const std::string& SearchRequest::text() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.text)
  return _internal_text();
}
inline void SearchRequest::set_text(const std::string& value) {
  _internal_set_text(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.text)
}
inline std::string* SearchRequest::mutable_text() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.text)
  return _internal_mutable_text();
}
inline const std::string& SearchRequest::_internal_text() const {
  return text_.Get();
}
inline void SearchRequest::_internal_set_text(const std::string& value) {
  
  text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_text(std::string&& value) {
  
  text_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.text)
}
inline void SearchRequest::set_text(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.text)
}
inline void SearchRequest::set_text(const char* value,
    size_t size) {
  
  text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.text)
}
inline std::string* SearchRequest::_internal_mutable_text() {
  
  return text_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_text() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.text)
  return text_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_text(std::string* text) {
  if (text != nullptr) {
    
  } else {
    
  }
  text_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), text,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.text)
}

// uint32 limit = 4;
inline void SearchRequest::clear_limit() {
  limit_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SearchRequest::_internal_limit() const {
  return limit_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SearchRequest::limit() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.limit)
  return _internal_limit();
}
inline void SearchRequest::_internal_set_limit(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  limit_ = value;
}
inline void SearchRequest::set_limit(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_limit(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.limit)
}

// repeated string order_by = 5;
inline int SearchRequest::_internal_order_by_size() const {
  return order_by_.size();
}
inline int SearchRequest::order_by_size() const {
  return _internal_order_by_size();
}
inline void SearchRequest::clear_order_by() {
  order_by_.Clear();
}
inline std::string* SearchRequest::add_order_by() {
  // @@protoc_insertion_point(field_add_mutable:pb.SearchRequest.order_by)
  return _internal_add_order_by();
}
inline const std::string& SearchRequest::_internal_order_by(int index) const {
  return order_by_.Get(index);
}
inline const std::string& SearchRequest::order_by(int index) const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.order_by)
  return _internal_order_by(index);
}
inline std::string* SearchRequest::mutable_order_by(int index) {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.order_by)
  return order_by_.Mutable(index);
}
inline void SearchRequest::set_order_by(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.order_by)
  order_by_.Mutable(index)->assign(value);
}
inline void SearchRequest::set_order_by(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.order_by)
  order_by_.Mutable(index)->assign(std::move(value));
}
inline void SearchRequest::set_order_by(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  order_by_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.order_by)
}
inline void SearchRequest::set_order_by(int index, const char* value, size_t size) {
  order_by_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.order_by)
}
inline std::string* SearchRequest::_internal_add_order_by() {
  return order_by_.Add();
}
inline void SearchRequest::add_order_by(const std::string& value) {
  order_by_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:pb.SearchRequest.order_by)
}
inline void SearchRequest::add_order_by(std::string&& value) {
  order_by_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:pb.SearchRequest.order_by)
}
inline void SearchRequest::add_order_by(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  order_by_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:pb.SearchRequest.order_by)
}
inline void SearchRequest::add_order_by(const char* value, size_t size) {
  order_by_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:pb.SearchRequest.order_by)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchRequest::order_by() const {
  // @@protoc_insertion_point(field_list:pb.SearchRequest.order_by)
  return order_by_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchRequest::mutable_order_by() {
  // @@protoc_insertion_point(field_mutable_list:pb.SearchRequest.order_by)
  return &order_by_;
}

// uint32 offset = 6;
inline void SearchRequest::clear_offset() {
  offset_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SearchRequest::_internal_offset() const {
  return offset_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SearchRequest::offset() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.offset)
  return _internal_offset();
}
inline void SearchRequest::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  offset_ = value;
}
inline void SearchRequest::set_offset(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_offset(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.offset)
}

// bool is_controlling = 7;
inline void SearchRequest::clear_is_controlling() {
  is_controlling_ = false;
}
inline bool SearchRequest::_internal_is_controlling() const {
  return is_controlling_;
}
inline bool SearchRequest::is_controlling() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.is_controlling)
  return _internal_is_controlling();
}
inline void SearchRequest::_internal_set_is_controlling(bool value) {
  
  is_controlling_ = value;
}
inline void SearchRequest::set_is_controlling(bool value) {
  _internal_set_is_controlling(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.is_controlling)
}

// string last_take_over_height = 8;
inline void SearchRequest::clear_last_take_over_height() {
  last_take_over_height_.ClearToEmpty();
}
inline const std::string& SearchRequest::last_take_over_height() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.last_take_over_height)
  return _internal_last_take_over_height();
}
inline void SearchRequest::set_last_take_over_height(const std::string& value) {
  _internal_set_last_take_over_height(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.last_take_over_height)
}
inline std::string* SearchRequest::mutable_last_take_over_height() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.last_take_over_height)
  return _internal_mutable_last_take_over_height();
}
inline const std::string& SearchRequest::_internal_last_take_over_height() const {
  return last_take_over_height_.Get();
}
inline void SearchRequest::_internal_set_last_take_over_height(const std::string& value) {
  
  last_take_over_height_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_last_take_over_height(std::string&& value) {
  
  last_take_over_height_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.last_take_over_height)
}
inline void SearchRequest::set_last_take_over_height(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  last_take_over_height_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.last_take_over_height)
}
inline void SearchRequest::set_last_take_over_height(const char* value,
    size_t size) {
  
  last_take_over_height_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.last_take_over_height)
}
inline std::string* SearchRequest::_internal_mutable_last_take_over_height() {
  
  return last_take_over_height_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_last_take_over_height() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.last_take_over_height)
  return last_take_over_height_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_last_take_over_height(std::string* last_take_over_height) {
  if (last_take_over_height != nullptr) {
    
  } else {
    
  }
  last_take_over_height_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), last_take_over_height,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.last_take_over_height)
}

// string name = 9;
inline void SearchRequest::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& SearchRequest::name() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.name)
  return _internal_name();
}
inline void SearchRequest::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.name)
}
inline std::string* SearchRequest::mutable_name() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.name)
  return _internal_mutable_name();
}
inline const std::string& SearchRequest::_internal_name() const {
  return name_.Get();
}
inline void SearchRequest::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.name)
}
inline void SearchRequest::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.name)
}
inline void SearchRequest::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.name)
}
inline std::string* SearchRequest::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_name() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.name)
}

// string normalized_name = 10;
inline void SearchRequest::clear_normalized_name() {
  normalized_name_.ClearToEmpty();
}
inline const std::string& SearchRequest::normalized_name() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.normalized_name)
  return _internal_normalized_name();
}
inline void SearchRequest::set_normalized_name(const std::string& value) {
  _internal_set_normalized_name(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.normalized_name)
}
inline std::string* SearchRequest::mutable_normalized_name() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.normalized_name)
  return _internal_mutable_normalized_name();
}
inline const std::string& SearchRequest::_internal_normalized_name() const {
  return normalized_name_.Get();
}
inline void SearchRequest::_internal_set_normalized_name(const std::string& value) {
  
  normalized_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_normalized_name(std::string&& value) {
  
  normalized_name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.normalized_name)
}
inline void SearchRequest::set_normalized_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  normalized_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.normalized_name)
}
inline void SearchRequest::set_normalized_name(const char* value,
    size_t size) {
  
  normalized_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.normalized_name)
}
inline std::string* SearchRequest::_internal_mutable_normalized_name() {
  
  return normalized_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_normalized_name() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.normalized_name)
  return normalized_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_normalized_name(std::string* normalized_name) {
  if (normalized_name != nullptr) {
    
  } else {
    
  }
  normalized_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), normalized_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.normalized_name)
}

// .pb.RangeField tx_position = 11;
inline bool SearchRequest::_internal_has_tx_position() const {
  return this != internal_default_instance() && tx_position_ != nullptr;
}
inline bool SearchRequest::has_tx_position() const {
  return _internal_has_tx_position();
}
inline void SearchRequest::clear_tx_position() {
  if (GetArena() == nullptr && tx_position_ != nullptr) {
    delete tx_position_;
  }
  tx_position_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_tx_position() const {
  const ::pb::RangeField* p = tx_position_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::tx_position() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.tx_position)
  return _internal_tx_position();
}
inline void SearchRequest::unsafe_arena_set_allocated_tx_position(
    ::pb::RangeField* tx_position) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tx_position_);
  }
  tx_position_ = tx_position;
  if (tx_position) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.tx_position)
}
inline ::pb::RangeField* SearchRequest::release_tx_position() {
  
  ::pb::RangeField* temp = tx_position_;
  tx_position_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_tx_position() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.tx_position)
  
  ::pb::RangeField* temp = tx_position_;
  tx_position_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_tx_position() {
  
  if (tx_position_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    tx_position_ = p;
  }
  return tx_position_;
}
inline ::pb::RangeField* SearchRequest::mutable_tx_position() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.tx_position)
  return _internal_mutable_tx_position();
}
inline void SearchRequest::set_allocated_tx_position(::pb::RangeField* tx_position) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete tx_position_;
  }
  if (tx_position) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(tx_position);
    if (message_arena != submessage_arena) {
      tx_position = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tx_position, submessage_arena);
    }
    
  } else {
    
  }
  tx_position_ = tx_position;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.tx_position)
}

// .pb.RangeField amount = 12;
inline bool SearchRequest::_internal_has_amount() const {
  return this != internal_default_instance() && amount_ != nullptr;
}
inline bool SearchRequest::has_amount() const {
  return _internal_has_amount();
}
inline void SearchRequest::clear_amount() {
  if (GetArena() == nullptr && amount_ != nullptr) {
    delete amount_;
  }
  amount_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_amount() const {
  const ::pb::RangeField* p = amount_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::amount() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.amount)
  return _internal_amount();
}
inline void SearchRequest::unsafe_arena_set_allocated_amount(
    ::pb::RangeField* amount) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(amount_);
  }
  amount_ = amount;
  if (amount) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.amount)
}
inline ::pb::RangeField* SearchRequest::release_amount() {
  
  ::pb::RangeField* temp = amount_;
  amount_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_amount() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.amount)
  
  ::pb::RangeField* temp = amount_;
  amount_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_amount() {
  
  if (amount_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    amount_ = p;
  }
  return amount_;
}
inline ::pb::RangeField* SearchRequest::mutable_amount() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.amount)
  return _internal_mutable_amount();
}
inline void SearchRequest::set_allocated_amount(::pb::RangeField* amount) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete amount_;
  }
  if (amount) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(amount);
    if (message_arena != submessage_arena) {
      amount = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, amount, submessage_arena);
    }
    
  } else {
    
  }
  amount_ = amount;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.amount)
}

// .pb.RangeField timestamp = 13;
inline bool SearchRequest::_internal_has_timestamp() const {
  return this != internal_default_instance() && timestamp_ != nullptr;
}
inline bool SearchRequest::has_timestamp() const {
  return _internal_has_timestamp();
}
inline void SearchRequest::clear_timestamp() {
  if (GetArena() == nullptr && timestamp_ != nullptr) {
    delete timestamp_;
  }
  timestamp_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_timestamp() const {
  const ::pb::RangeField* p = timestamp_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::timestamp() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.timestamp)
  return _internal_timestamp();
}
inline void SearchRequest::unsafe_arena_set_allocated_timestamp(
    ::pb::RangeField* timestamp) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp_);
  }
  timestamp_ = timestamp;
  if (timestamp) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.timestamp)
}
inline ::pb::RangeField* SearchRequest::release_timestamp() {
  
  ::pb::RangeField* temp = timestamp_;
  timestamp_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_timestamp() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.timestamp)
  
  ::pb::RangeField* temp = timestamp_;
  timestamp_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_timestamp() {
  
  if (timestamp_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    timestamp_ = p;
  }
  return timestamp_;
}
inline ::pb::RangeField* SearchRequest::mutable_timestamp() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.timestamp)
  return _internal_mutable_timestamp();
}
inline void SearchRequest::set_allocated_timestamp(::pb::RangeField* timestamp) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete timestamp_;
  }
  if (timestamp) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(timestamp);
    if (message_arena != submessage_arena) {
      timestamp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, timestamp, submessage_arena);
    }
    
  } else {
    
  }
  timestamp_ = timestamp;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.timestamp)
}

// .pb.RangeField creation_timestamp = 14;
inline bool SearchRequest::_internal_has_creation_timestamp() const {
  return this != internal_default_instance() && creation_timestamp_ != nullptr;
}
inline bool SearchRequest::has_creation_timestamp() const {
  return _internal_has_creation_timestamp();
}
inline void SearchRequest::clear_creation_timestamp() {
  if (GetArena() == nullptr && creation_timestamp_ != nullptr) {
    delete creation_timestamp_;
  }
  creation_timestamp_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_creation_timestamp() const {
  const ::pb::RangeField* p = creation_timestamp_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::creation_timestamp() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.creation_timestamp)
  return _internal_creation_timestamp();
}
inline void SearchRequest::unsafe_arena_set_allocated_creation_timestamp(
    ::pb::RangeField* creation_timestamp) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(creation_timestamp_);
  }
  creation_timestamp_ = creation_timestamp;
  if (creation_timestamp) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.creation_timestamp)
}
inline ::pb::RangeField* SearchRequest::release_creation_timestamp() {
  
  ::pb::RangeField* temp = creation_timestamp_;
  creation_timestamp_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_creation_timestamp() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.creation_timestamp)
  
  ::pb::RangeField* temp = creation_timestamp_;
  creation_timestamp_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_creation_timestamp() {
  
  if (creation_timestamp_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    creation_timestamp_ = p;
  }
  return creation_timestamp_;
}
inline ::pb::RangeField* SearchRequest::mutable_creation_timestamp() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.creation_timestamp)
  return _internal_mutable_creation_timestamp();
}
inline void SearchRequest::set_allocated_creation_timestamp(::pb::RangeField* creation_timestamp) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete creation_timestamp_;
  }
  if (creation_timestamp) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(creation_timestamp);
    if (message_arena != submessage_arena) {
      creation_timestamp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, creation_timestamp, submessage_arena);
    }
    
  } else {
    
  }
  creation_timestamp_ = creation_timestamp;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.creation_timestamp)
}

// .pb.RangeField height = 15;
inline bool SearchRequest::_internal_has_height() const {
  return this != internal_default_instance() && height_ != nullptr;
}
inline bool SearchRequest::has_height() const {
  return _internal_has_height();
}
inline void SearchRequest::clear_height() {
  if (GetArena() == nullptr && height_ != nullptr) {
    delete height_;
  }
  height_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_height() const {
  const ::pb::RangeField* p = height_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::height() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.height)
  return _internal_height();
}
inline void SearchRequest::unsafe_arena_set_allocated_height(
    ::pb::RangeField* height) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(height_);
  }
  height_ = height;
  if (height) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.height)
}
inline ::pb::RangeField* SearchRequest::release_height() {
  
  ::pb::RangeField* temp = height_;
  height_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_height() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.height)
  
  ::pb::RangeField* temp = height_;
  height_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_height() {
  
  if (height_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    height_ = p;
  }
  return height_;
}
inline ::pb::RangeField* SearchRequest::mutable_height() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.height)
  return _internal_mutable_height();
}
inline void SearchRequest::set_allocated_height(::pb::RangeField* height) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete height_;
  }
  if (height) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(height);
    if (message_arena != submessage_arena) {
      height = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, height, submessage_arena);
    }
    
  } else {
    
  }
  height_ = height;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.height)
}

// .pb.RangeField creation_height = 16;
inline bool SearchRequest::_internal_has_creation_height() const {
  return this != internal_default_instance() && creation_height_ != nullptr;
}
inline bool SearchRequest::has_creation_height() const {
  return _internal_has_creation_height();
}
inline void SearchRequest::clear_creation_height() {
  if (GetArena() == nullptr && creation_height_ != nullptr) {
    delete creation_height_;
  }
  creation_height_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_creation_height() const {
  const ::pb::RangeField* p = creation_height_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::creation_height() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.creation_height)
  return _internal_creation_height();
}
inline void SearchRequest::unsafe_arena_set_allocated_creation_height(
    ::pb::RangeField* creation_height) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(creation_height_);
  }
  creation_height_ = creation_height;
  if (creation_height) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.creation_height)
}
inline ::pb::RangeField* SearchRequest::release_creation_height() {
  
  ::pb::RangeField* temp = creation_height_;
  creation_height_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_creation_height() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.creation_height)
  
  ::pb::RangeField* temp = creation_height_;
  creation_height_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_creation_height() {
  
  if (creation_height_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    creation_height_ = p;
  }
  return creation_height_;
}
inline ::pb::RangeField* SearchRequest::mutable_creation_height() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.creation_height)
  return _internal_mutable_creation_height();
}
inline void SearchRequest::set_allocated_creation_height(::pb::RangeField* creation_height) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete creation_height_;
  }
  if (creation_height) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(creation_height);
    if (message_arena != submessage_arena) {
      creation_height = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, creation_height, submessage_arena);
    }
    
  } else {
    
  }
  creation_height_ = creation_height;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.creation_height)
}

// .pb.RangeField activation_height = 17;
inline bool SearchRequest::_internal_has_activation_height() const {
  return this != internal_default_instance() && activation_height_ != nullptr;
}
inline bool SearchRequest::has_activation_height() const {
  return _internal_has_activation_height();
}
inline void SearchRequest::clear_activation_height() {
  if (GetArena() == nullptr && activation_height_ != nullptr) {
    delete activation_height_;
  }
  activation_height_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_activation_height() const {
  const ::pb::RangeField* p = activation_height_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::activation_height() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.activation_height)
  return _internal_activation_height();
}
inline void SearchRequest::unsafe_arena_set_allocated_activation_height(
    ::pb::RangeField* activation_height) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(activation_height_);
  }
  activation_height_ = activation_height;
  if (activation_height) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.activation_height)
}
inline ::pb::RangeField* SearchRequest::release_activation_height() {
  
  ::pb::RangeField* temp = activation_height_;
  activation_height_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_activation_height() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.activation_height)
  
  ::pb::RangeField* temp = activation_height_;
  activation_height_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_activation_height() {
  
  if (activation_height_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    activation_height_ = p;
  }
  return activation_height_;
}
inline ::pb::RangeField* SearchRequest::mutable_activation_height() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.activation_height)
  return _internal_mutable_activation_height();
}
inline void SearchRequest::set_allocated_activation_height(::pb::RangeField* activation_height) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete activation_height_;
  }
  if (activation_height) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(activation_height);
    if (message_arena != submessage_arena) {
      activation_height = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, activation_height, submessage_arena);
    }
    
  } else {
    
  }
  activation_height_ = activation_height;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.activation_height)
}

// .pb.RangeField expiration_height = 18;
inline bool SearchRequest::_internal_has_expiration_height() const {
  return this != internal_default_instance() && expiration_height_ != nullptr;
}
inline bool SearchRequest::has_expiration_height() const {
  return _internal_has_expiration_height();
}
inline void SearchRequest::clear_expiration_height() {
  if (GetArena() == nullptr && expiration_height_ != nullptr) {
    delete expiration_height_;
  }
  expiration_height_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_expiration_height() const {
  const ::pb::RangeField* p = expiration_height_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::expiration_height() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.expiration_height)
  return _internal_expiration_height();
}
inline void SearchRequest::unsafe_arena_set_allocated_expiration_height(
    ::pb::RangeField* expiration_height) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expiration_height_);
  }
  expiration_height_ = expiration_height;
  if (expiration_height) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.expiration_height)
}
inline ::pb::RangeField* SearchRequest::release_expiration_height() {
  
  ::pb::RangeField* temp = expiration_height_;
  expiration_height_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_expiration_height() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.expiration_height)
  
  ::pb::RangeField* temp = expiration_height_;
  expiration_height_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_expiration_height() {
  
  if (expiration_height_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    expiration_height_ = p;
  }
  return expiration_height_;
}
inline ::pb::RangeField* SearchRequest::mutable_expiration_height() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.expiration_height)
  return _internal_mutable_expiration_height();
}
inline void SearchRequest::set_allocated_expiration_height(::pb::RangeField* expiration_height) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete expiration_height_;
  }
  if (expiration_height) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expiration_height);
    if (message_arena != submessage_arena) {
      expiration_height = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, expiration_height, submessage_arena);
    }
    
  } else {
    
  }
  expiration_height_ = expiration_height;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.expiration_height)
}

// .pb.RangeField release_time = 19;
inline bool SearchRequest::_internal_has_release_time() const {
  return this != internal_default_instance() && release_time_ != nullptr;
}
inline bool SearchRequest::has_release_time() const {
  return _internal_has_release_time();
}
inline void SearchRequest::clear_release_time() {
  if (GetArena() == nullptr && release_time_ != nullptr) {
    delete release_time_;
  }
  release_time_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_release_time() const {
  const ::pb::RangeField* p = release_time_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::release_time() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.release_time)
  return _internal_release_time();
}
inline void SearchRequest::unsafe_arena_set_allocated_release_time(
    ::pb::RangeField* release_time) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(release_time_);
  }
  release_time_ = release_time;
  if (release_time) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.release_time)
}
inline ::pb::RangeField* SearchRequest::release_release_time() {
  
  ::pb::RangeField* temp = release_time_;
  release_time_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_release_time() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.release_time)
  
  ::pb::RangeField* temp = release_time_;
  release_time_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_release_time() {
  
  if (release_time_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    release_time_ = p;
  }
  return release_time_;
}
inline ::pb::RangeField* SearchRequest::mutable_release_time() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.release_time)
  return _internal_mutable_release_time();
}
inline void SearchRequest::set_allocated_release_time(::pb::RangeField* release_time) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete release_time_;
  }
  if (release_time) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(release_time);
    if (message_arena != submessage_arena) {
      release_time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, release_time, submessage_arena);
    }
    
  } else {
    
  }
  release_time_ = release_time;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.release_time)
}

// string short_url = 20;
inline void SearchRequest::clear_short_url() {
  short_url_.ClearToEmpty();
}
inline const std::string& SearchRequest::short_url() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.short_url)
  return _internal_short_url();
}
inline void SearchRequest::set_short_url(const std::string& value) {
  _internal_set_short_url(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.short_url)
}
inline std::string* SearchRequest::mutable_short_url() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.short_url)
  return _internal_mutable_short_url();
}
inline const std::string& SearchRequest::_internal_short_url() const {
  return short_url_.Get();
}
inline void SearchRequest::_internal_set_short_url(const std::string& value) {
  
  short_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_short_url(std::string&& value) {
  
  short_url_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.short_url)
}
inline void SearchRequest::set_short_url(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  short_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.short_url)
}
inline void SearchRequest::set_short_url(const char* value,
    size_t size) {
  
  short_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.short_url)
}
inline std::string* SearchRequest::_internal_mutable_short_url() {
  
  return short_url_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_short_url() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.short_url)
  return short_url_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_short_url(std::string* short_url) {
  if (short_url != nullptr) {
    
  } else {
    
  }
  short_url_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), short_url,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.short_url)
}

// string canonical_url = 21;
inline void SearchRequest::clear_canonical_url() {
  canonical_url_.ClearToEmpty();
}
inline const std::string& SearchRequest::canonical_url() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.canonical_url)
  return _internal_canonical_url();
}
inline void SearchRequest::set_canonical_url(const std::string& value) {
  _internal_set_canonical_url(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.canonical_url)
}
inline std::string* SearchRequest::mutable_canonical_url() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.canonical_url)
  return _internal_mutable_canonical_url();
}
inline const std::string& SearchRequest::_internal_canonical_url() const {
  return canonical_url_.Get();
}
inline void SearchRequest::_internal_set_canonical_url(const std::string& value) {
  
  canonical_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_canonical_url(std::string&& value) {
  
  canonical_url_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.canonical_url)
}
inline void SearchRequest::set_canonical_url(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  canonical_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.canonical_url)
}
inline void SearchRequest::set_canonical_url(const char* value,
    size_t size) {
  
  canonical_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.canonical_url)
}
inline std::string* SearchRequest::_internal_mutable_canonical_url() {
  
  return canonical_url_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_canonical_url() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.canonical_url)
  return canonical_url_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_canonical_url(std::string* canonical_url) {
  if (canonical_url != nullptr) {
    
  } else {
    
  }
  canonical_url_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), canonical_url,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.canonical_url)
}

// string title = 22;
inline void SearchRequest::clear_title() {
  title_.ClearToEmpty();
}
inline const std::string& SearchRequest::title() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.title)
  return _internal_title();
}
inline void SearchRequest::set_title(const std::string& value) {
  _internal_set_title(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.title)
}
inline std::string* SearchRequest::mutable_title() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.title)
  return _internal_mutable_title();
}
inline const std::string& SearchRequest::_internal_title() const {
  return title_.Get();
}
inline void SearchRequest::_internal_set_title(const std::string& value) {
  
  title_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_title(std::string&& value) {
  
  title_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.title)
}
inline void SearchRequest::set_title(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  title_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.title)
}
inline void SearchRequest::set_title(const char* value,
    size_t size) {
  
  title_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.title)
}
inline std::string* SearchRequest::_internal_mutable_title() {
  
  return title_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_title() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.title)
  return title_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_title(std::string* title) {
  if (title != nullptr) {
    
  } else {
    
  }
  title_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), title,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.title)
}

// string author = 23;
inline void SearchRequest::clear_author() {
  author_.ClearToEmpty();
}
inline const std::string& SearchRequest::author() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.author)
  return _internal_author();
}
inline void SearchRequest::set_author(const std::string& value) {
  _internal_set_author(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.author)
}
inline std::string* SearchRequest::mutable_author() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.author)
  return _internal_mutable_author();
}
inline const std::string& SearchRequest::_internal_author() const {
  return author_.Get();
}
inline void SearchRequest::_internal_set_author(const std::string& value) {
  
  author_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_author(std::string&& value) {
  
  author_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.author)
}
inline void SearchRequest::set_author(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  author_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.author)
}
inline void SearchRequest::set_author(const char* value,
    size_t size) {
  
  author_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.author)
}
inline std::string* SearchRequest::_internal_mutable_author() {
  
  return author_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_author() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.author)
  return author_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_author(std::string* author) {
  if (author != nullptr) {
    
  } else {
    
  }
  author_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), author,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.author)
}

// string description = 24;
inline void SearchRequest::clear_description() {
  description_.ClearToEmpty();
}
inline const std::string& SearchRequest::description() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.description)
  return _internal_description();
}
inline void SearchRequest::set_description(const std::string& value) {
  _internal_set_description(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.description)
}
inline std::string* SearchRequest::mutable_description() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.description)
  return _internal_mutable_description();
}
inline const std::string& SearchRequest::_internal_description() const {
  return description_.Get();
}
inline void SearchRequest::_internal_set_description(const std::string& value) {
  
  description_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_description(std::string&& value) {
  
  description_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.description)
}
inline void SearchRequest::set_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  description_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.description)
}
inline void SearchRequest::set_description(const char* value,
    size_t size) {
  
  description_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.description)
}
inline std::string* SearchRequest::_internal_mutable_description() {
  
  return description_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_description() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.description)
  return description_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    
  } else {
    
  }
  description_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.description)
}

// repeated string claim_type = 25;
inline int SearchRequest::_internal_claim_type_size() const {
  return claim_type_.size();
}
inline int SearchRequest::claim_type_size() const {
  return _internal_claim_type_size();
}
inline void SearchRequest::clear_claim_type() {
  claim_type_.Clear();
}
inline std::string* SearchRequest::add_claim_type() {
  // @@protoc_insertion_point(field_add_mutable:pb.SearchRequest.claim_type)
  return _internal_add_claim_type();
}
inline const std::string& SearchRequest::_internal_claim_type(int index) const {
  return claim_type_.Get(index);
}
inline const std::string& SearchRequest::claim_type(int index) const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.claim_type)
  return _internal_claim_type(index);
}
inline std::string* SearchRequest::mutable_claim_type(int index) {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.claim_type)
  return claim_type_.Mutable(index);
}
inline void SearchRequest::set_claim_type(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.claim_type)
  claim_type_.Mutable(index)->assign(value);
}
inline void SearchRequest::set_claim_type(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.claim_type)
  claim_type_.Mutable(index)->assign(std::move(value));
}
inline void SearchRequest::set_claim_type(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  claim_type_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.claim_type)
}
inline void SearchRequest::set_claim_type(int index, const char* value, size_t size) {
  claim_type_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.claim_type)
}
inline std::string* SearchRequest::_internal_add_claim_type() {
  return claim_type_.Add();
}
inline void SearchRequest::add_claim_type(const std::string& value) {
  claim_type_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:pb.SearchRequest.claim_type)
}
inline void SearchRequest::add_claim_type(std::string&& value) {
  claim_type_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:pb.SearchRequest.claim_type)
}
inline void SearchRequest::add_claim_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  claim_type_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:pb.SearchRequest.claim_type)
}
inline void SearchRequest::add_claim_type(const char* value, size_t size) {
  claim_type_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:pb.SearchRequest.claim_type)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchRequest::claim_type() const {
  // @@protoc_insertion_point(field_list:pb.SearchRequest.claim_type)
  return claim_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchRequest::mutable_claim_type() {
  // @@protoc_insertion_point(field_mutable_list:pb.SearchRequest.claim_type)
  return &claim_type_;
}

// .pb.RangeField repost_count = 26;
inline bool SearchRequest::_internal_has_repost_count() const {
  return this != internal_default_instance() && repost_count_ != nullptr;
}
inline bool SearchRequest::has_repost_count() const {
  return _internal_has_repost_count();
}
inline void SearchRequest::clear_repost_count() {
  if (GetArena() == nullptr && repost_count_ != nullptr) {
    delete repost_count_;
  }
  repost_count_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_repost_count() const {
  const ::pb::RangeField* p = repost_count_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::repost_count() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.repost_count)
  return _internal_repost_count();
}
inline void SearchRequest::unsafe_arena_set_allocated_repost_count(
    ::pb::RangeField* repost_count) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(repost_count_);
  }
  repost_count_ = repost_count;
  if (repost_count) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.repost_count)
}
inline ::pb::RangeField* SearchRequest::release_repost_count() {
  
  ::pb::RangeField* temp = repost_count_;
  repost_count_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_repost_count() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.repost_count)
  
  ::pb::RangeField* temp = repost_count_;
  repost_count_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_repost_count() {
  
  if (repost_count_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    repost_count_ = p;
  }
  return repost_count_;
}
inline ::pb::RangeField* SearchRequest::mutable_repost_count() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.repost_count)
  return _internal_mutable_repost_count();
}
inline void SearchRequest::set_allocated_repost_count(::pb::RangeField* repost_count) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete repost_count_;
  }
  if (repost_count) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(repost_count);
    if (message_arena != submessage_arena) {
      repost_count = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, repost_count, submessage_arena);
    }
    
  } else {
    
  }
  repost_count_ = repost_count;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.repost_count)
}

// repeated string stream_type = 27;
inline int SearchRequest::_internal_stream_type_size() const {
  return stream_type_.size();
}
inline int SearchRequest::stream_type_size() const {
  return _internal_stream_type_size();
}
inline void SearchRequest::clear_stream_type() {
  stream_type_.Clear();
}
inline std::string* SearchRequest::add_stream_type() {
  // @@protoc_insertion_point(field_add_mutable:pb.SearchRequest.stream_type)
  return _internal_add_stream_type();
}
inline const std::string& SearchRequest::_internal_stream_type(int index) const {
  return stream_type_.Get(index);
}
inline const std::string& SearchRequest::stream_type(int index) const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.stream_type)
  return _internal_stream_type(index);
}
inline std::string* SearchRequest::mutable_stream_type(int index) {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.stream_type)
  return stream_type_.Mutable(index);
}
inline void SearchRequest::set_stream_type(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.stream_type)
  stream_type_.Mutable(index)->assign(value);
}
inline void SearchRequest::set_stream_type(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.stream_type)
  stream_type_.Mutable(index)->assign(std::move(value));
}
inline void SearchRequest::set_stream_type(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  stream_type_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.stream_type)
}
inline void SearchRequest::set_stream_type(int index, const char* value, size_t size) {
  stream_type_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.stream_type)
}
inline std::string* SearchRequest::_internal_add_stream_type() {
  return stream_type_.Add();
}
inline void SearchRequest::add_stream_type(const std::string& value) {
  stream_type_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:pb.SearchRequest.stream_type)
}
inline void SearchRequest::add_stream_type(std::string&& value) {
  stream_type_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:pb.SearchRequest.stream_type)
}
inline void SearchRequest::add_stream_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  stream_type_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:pb.SearchRequest.stream_type)
}
inline void SearchRequest::add_stream_type(const char* value, size_t size) {
  stream_type_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:pb.SearchRequest.stream_type)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchRequest::stream_type() const {
  // @@protoc_insertion_point(field_list:pb.SearchRequest.stream_type)
  return stream_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchRequest::mutable_stream_type() {
  // @@protoc_insertion_point(field_mutable_list:pb.SearchRequest.stream_type)
  return &stream_type_;
}

// repeated string media_type = 28;
inline int SearchRequest::_internal_media_type_size() const {
  return media_type_.size();
}
inline int SearchRequest::media_type_size() const {
  return _internal_media_type_size();
}
inline void SearchRequest::clear_media_type() {
  media_type_.Clear();
}
inline std::string* SearchRequest::add_media_type() {
  // @@protoc_insertion_point(field_add_mutable:pb.SearchRequest.media_type)
  return _internal_add_media_type();
}
inline const std::string& SearchRequest::_internal_media_type(int index) const {
  return media_type_.Get(index);
}
inline const std::string& SearchRequest::media_type(int index) const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.media_type)
  return _internal_media_type(index);
}
inline std::string* SearchRequest::mutable_media_type(int index) {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.media_type)
  return media_type_.Mutable(index);
}
inline void SearchRequest::set_media_type(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.media_type)
  media_type_.Mutable(index)->assign(value);
}
inline void SearchRequest::set_media_type(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.media_type)
  media_type_.Mutable(index)->assign(std::move(value));
}
inline void SearchRequest::set_media_type(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  media_type_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.media_type)
}
inline void SearchRequest::set_media_type(int index, const char* value, size_t size) {
  media_type_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.media_type)
}
inline std::string* SearchRequest::_internal_add_media_type() {
  return media_type_.Add();
}
inline void SearchRequest::add_media_type(const std::string& value) {
  media_type_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:pb.SearchRequest.media_type)
}
inline void SearchRequest::add_media_type(std::string&& value) {
  media_type_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:pb.SearchRequest.media_type)
}
inline void SearchRequest::add_media_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  media_type_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:pb.SearchRequest.media_type)
}
inline void SearchRequest::add_media_type(const char* value, size_t size) {
  media_type_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:pb.SearchRequest.media_type)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchRequest::media_type() const {
  // @@protoc_insertion_point(field_list:pb.SearchRequest.media_type)
  return media_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchRequest::mutable_media_type() {
  // @@protoc_insertion_point(field_mutable_list:pb.SearchRequest.media_type)
  return &media_type_;
}

// .pb.RangeField fee_amount = 29;
inline bool SearchRequest::_internal_has_fee_amount() const {
  return this != internal_default_instance() && fee_amount_ != nullptr;
}
inline bool SearchRequest::has_fee_amount() const {
  return _internal_has_fee_amount();
}
inline void SearchRequest::clear_fee_amount() {
  if (GetArena() == nullptr && fee_amount_ != nullptr) {
    delete fee_amount_;
  }
  fee_amount_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_fee_amount() const {
  const ::pb::RangeField* p = fee_amount_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::fee_amount() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.fee_amount)
  return _internal_fee_amount();
}
inline void SearchRequest::unsafe_arena_set_allocated_fee_amount(
    ::pb::RangeField* fee_amount) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fee_amount_);
  }
  fee_amount_ = fee_amount;
  if (fee_amount) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.fee_amount)
}
inline ::pb::RangeField* SearchRequest::release_fee_amount() {
  
  ::pb::RangeField* temp = fee_amount_;
  fee_amount_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_fee_amount() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.fee_amount)
  
  ::pb::RangeField* temp = fee_amount_;
  fee_amount_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_fee_amount() {
  
  if (fee_amount_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    fee_amount_ = p;
  }
  return fee_amount_;
}
inline ::pb::RangeField* SearchRequest::mutable_fee_amount() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.fee_amount)
  return _internal_mutable_fee_amount();
}
inline void SearchRequest::set_allocated_fee_amount(::pb::RangeField* fee_amount) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete fee_amount_;
  }
  if (fee_amount) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fee_amount);
    if (message_arena != submessage_arena) {
      fee_amount = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, fee_amount, submessage_arena);
    }
    
  } else {
    
  }
  fee_amount_ = fee_amount;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.fee_amount)
}

// string fee_currency = 30;
inline void SearchRequest::clear_fee_currency() {
  fee_currency_.ClearToEmpty();
}
inline const std::string& SearchRequest::fee_currency() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.fee_currency)
  return _internal_fee_currency();
}
inline void SearchRequest::set_fee_currency(const std::string& value) {
  _internal_set_fee_currency(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.fee_currency)
}
inline std::string* SearchRequest::mutable_fee_currency() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.fee_currency)
  return _internal_mutable_fee_currency();
}
inline const std::string& SearchRequest::_internal_fee_currency() const {
  return fee_currency_.Get();
}
inline void SearchRequest::_internal_set_fee_currency(const std::string& value) {
  
  fee_currency_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_fee_currency(std::string&& value) {
  
  fee_currency_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.fee_currency)
}
inline void SearchRequest::set_fee_currency(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  fee_currency_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.fee_currency)
}
inline void SearchRequest::set_fee_currency(const char* value,
    size_t size) {
  
  fee_currency_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.fee_currency)
}
inline std::string* SearchRequest::_internal_mutable_fee_currency() {
  
  return fee_currency_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_fee_currency() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.fee_currency)
  return fee_currency_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_fee_currency(std::string* fee_currency) {
  if (fee_currency != nullptr) {
    
  } else {
    
  }
  fee_currency_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fee_currency,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.fee_currency)
}

// .pb.RangeField duration = 31;
inline bool SearchRequest::_internal_has_duration() const {
  return this != internal_default_instance() && duration_ != nullptr;
}
inline bool SearchRequest::has_duration() const {
  return _internal_has_duration();
}
inline void SearchRequest::clear_duration() {
  if (GetArena() == nullptr && duration_ != nullptr) {
    delete duration_;
  }
  duration_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_duration() const {
  const ::pb::RangeField* p = duration_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::duration() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.duration)
  return _internal_duration();
}
inline void SearchRequest::unsafe_arena_set_allocated_duration(
    ::pb::RangeField* duration) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(duration_);
  }
  duration_ = duration;
  if (duration) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.duration)
}
inline ::pb::RangeField* SearchRequest::release_duration() {
  
  ::pb::RangeField* temp = duration_;
  duration_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_duration() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.duration)
  
  ::pb::RangeField* temp = duration_;
  duration_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_duration() {
  
  if (duration_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    duration_ = p;
  }
  return duration_;
}
inline ::pb::RangeField* SearchRequest::mutable_duration() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.duration)
  return _internal_mutable_duration();
}
inline void SearchRequest::set_allocated_duration(::pb::RangeField* duration) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete duration_;
  }
  if (duration) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(duration);
    if (message_arena != submessage_arena) {
      duration = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, duration, submessage_arena);
    }
    
  } else {
    
  }
  duration_ = duration;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.duration)
}

// string reposted_claim_id = 32;
inline void SearchRequest::clear_reposted_claim_id() {
  reposted_claim_id_.ClearToEmpty();
}
inline const std::string& SearchRequest::reposted_claim_id() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.reposted_claim_id)
  return _internal_reposted_claim_id();
}
inline void SearchRequest::set_reposted_claim_id(const std::string& value) {
  _internal_set_reposted_claim_id(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.reposted_claim_id)
}
inline std::string* SearchRequest::mutable_reposted_claim_id() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.reposted_claim_id)
  return _internal_mutable_reposted_claim_id();
}
inline const std::string& SearchRequest::_internal_reposted_claim_id() const {
  return reposted_claim_id_.Get();
}
inline void SearchRequest::_internal_set_reposted_claim_id(const std::string& value) {
  
  reposted_claim_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_reposted_claim_id(std::string&& value) {
  
  reposted_claim_id_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.reposted_claim_id)
}
inline void SearchRequest::set_reposted_claim_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  reposted_claim_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.reposted_claim_id)
}
inline void SearchRequest::set_reposted_claim_id(const char* value,
    size_t size) {
  
  reposted_claim_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.reposted_claim_id)
}
inline std::string* SearchRequest::_internal_mutable_reposted_claim_id() {
  
  return reposted_claim_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_reposted_claim_id() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.reposted_claim_id)
  return reposted_claim_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_reposted_claim_id(std::string* reposted_claim_id) {
  if (reposted_claim_id != nullptr) {
    
  } else {
    
  }
  reposted_claim_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), reposted_claim_id,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.reposted_claim_id)
}

// .pb.RangeField censor_type = 33;
inline bool SearchRequest::_internal_has_censor_type() const {
  return this != internal_default_instance() && censor_type_ != nullptr;
}
inline bool SearchRequest::has_censor_type() const {
  return _internal_has_censor_type();
}
inline void SearchRequest::clear_censor_type() {
  if (GetArena() == nullptr && censor_type_ != nullptr) {
    delete censor_type_;
  }
  censor_type_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_censor_type() const {
  const ::pb::RangeField* p = censor_type_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::censor_type() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.censor_type)
  return _internal_censor_type();
}
inline void SearchRequest::unsafe_arena_set_allocated_censor_type(
    ::pb::RangeField* censor_type) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(censor_type_);
  }
  censor_type_ = censor_type;
  if (censor_type) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.censor_type)
}
inline ::pb::RangeField* SearchRequest::release_censor_type() {
  
  ::pb::RangeField* temp = censor_type_;
  censor_type_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_censor_type() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.censor_type)
  
  ::pb::RangeField* temp = censor_type_;
  censor_type_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_censor_type() {
  
  if (censor_type_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    censor_type_ = p;
  }
  return censor_type_;
}
inline ::pb::RangeField* SearchRequest::mutable_censor_type() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.censor_type)
  return _internal_mutable_censor_type();
}
inline void SearchRequest::set_allocated_censor_type(::pb::RangeField* censor_type) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete censor_type_;
  }
  if (censor_type) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(censor_type);
    if (message_arena != submessage_arena) {
      censor_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, censor_type, submessage_arena);
    }
    
  } else {
    
  }
  censor_type_ = censor_type;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.censor_type)
}

// string claims_in_channel = 34;
inline void SearchRequest::clear_claims_in_channel() {
  claims_in_channel_.ClearToEmpty();
}
inline const std::string& SearchRequest::claims_in_channel() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.claims_in_channel)
  return _internal_claims_in_channel();
}
inline void SearchRequest::set_claims_in_channel(const std::string& value) {
  _internal_set_claims_in_channel(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.claims_in_channel)
}
inline std::string* SearchRequest::mutable_claims_in_channel() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.claims_in_channel)
  return _internal_mutable_claims_in_channel();
}
inline const std::string& SearchRequest::_internal_claims_in_channel() const {
  return claims_in_channel_.Get();
}
inline void SearchRequest::_internal_set_claims_in_channel(const std::string& value) {
  
  claims_in_channel_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_claims_in_channel(std::string&& value) {
  
  claims_in_channel_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.claims_in_channel)
}
inline void SearchRequest::set_claims_in_channel(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  claims_in_channel_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.claims_in_channel)
}
inline void SearchRequest::set_claims_in_channel(const char* value,
    size_t size) {
  
  claims_in_channel_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.claims_in_channel)
}
inline std::string* SearchRequest::_internal_mutable_claims_in_channel() {
  
  return claims_in_channel_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_claims_in_channel() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.claims_in_channel)
  return claims_in_channel_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_claims_in_channel(std::string* claims_in_channel) {
  if (claims_in_channel != nullptr) {
    
  } else {
    
  }
  claims_in_channel_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), claims_in_channel,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.claims_in_channel)
}

// .pb.RangeField channel_join = 35;
inline bool SearchRequest::_internal_has_channel_join() const {
  return this != internal_default_instance() && channel_join_ != nullptr;
}
inline bool SearchRequest::has_channel_join() const {
  return _internal_has_channel_join();
}
inline void SearchRequest::clear_channel_join() {
  if (GetArena() == nullptr && channel_join_ != nullptr) {
    delete channel_join_;
  }
  channel_join_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_channel_join() const {
  const ::pb::RangeField* p = channel_join_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::channel_join() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.channel_join)
  return _internal_channel_join();
}
inline void SearchRequest::unsafe_arena_set_allocated_channel_join(
    ::pb::RangeField* channel_join) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(channel_join_);
  }
  channel_join_ = channel_join;
  if (channel_join) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.channel_join)
}
inline ::pb::RangeField* SearchRequest::release_channel_join() {
  
  ::pb::RangeField* temp = channel_join_;
  channel_join_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_channel_join() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.channel_join)
  
  ::pb::RangeField* temp = channel_join_;
  channel_join_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_channel_join() {
  
  if (channel_join_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    channel_join_ = p;
  }
  return channel_join_;
}
inline ::pb::RangeField* SearchRequest::mutable_channel_join() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.channel_join)
  return _internal_mutable_channel_join();
}
inline void SearchRequest::set_allocated_channel_join(::pb::RangeField* channel_join) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete channel_join_;
  }
  if (channel_join) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(channel_join);
    if (message_arena != submessage_arena) {
      channel_join = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, channel_join, submessage_arena);
    }
    
  } else {
    
  }
  channel_join_ = channel_join;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.channel_join)
}

// .pb.BoolValue is_signature_valid = 36;
inline bool SearchRequest::_internal_has_is_signature_valid() const {
  return this != internal_default_instance() && is_signature_valid_ != nullptr;
}
inline bool SearchRequest::has_is_signature_valid() const {
  return _internal_has_is_signature_valid();
}
inline void SearchRequest::clear_is_signature_valid() {
  if (GetArena() == nullptr && is_signature_valid_ != nullptr) {
    delete is_signature_valid_;
  }
  is_signature_valid_ = nullptr;
}
inline const ::pb::BoolValue& SearchRequest::_internal_is_signature_valid() const {
  const ::pb::BoolValue* p = is_signature_valid_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::BoolValue&>(
      ::pb::_BoolValue_default_instance_);
}
inline const ::pb::BoolValue& SearchRequest::is_signature_valid() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.is_signature_valid)
  return _internal_is_signature_valid();
}
inline void SearchRequest::unsafe_arena_set_allocated_is_signature_valid(
    ::pb::BoolValue* is_signature_valid) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(is_signature_valid_);
  }
  is_signature_valid_ = is_signature_valid;
  if (is_signature_valid) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.is_signature_valid)
}
inline ::pb::BoolValue* SearchRequest::release_is_signature_valid() {
  
  ::pb::BoolValue* temp = is_signature_valid_;
  is_signature_valid_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::BoolValue* SearchRequest::unsafe_arena_release_is_signature_valid() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.is_signature_valid)
  
  ::pb::BoolValue* temp = is_signature_valid_;
  is_signature_valid_ = nullptr;
  return temp;
}
inline ::pb::BoolValue* SearchRequest::_internal_mutable_is_signature_valid() {
  
  if (is_signature_valid_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::BoolValue>(GetArena());
    is_signature_valid_ = p;
  }
  return is_signature_valid_;
}
inline ::pb::BoolValue* SearchRequest::mutable_is_signature_valid() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.is_signature_valid)
  return _internal_mutable_is_signature_valid();
}
inline void SearchRequest::set_allocated_is_signature_valid(::pb::BoolValue* is_signature_valid) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete is_signature_valid_;
  }
  if (is_signature_valid) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(is_signature_valid);
    if (message_arena != submessage_arena) {
      is_signature_valid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, is_signature_valid, submessage_arena);
    }
    
  } else {
    
  }
  is_signature_valid_ = is_signature_valid;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.is_signature_valid)
}

// .pb.RangeField effective_amount = 37;
inline bool SearchRequest::_internal_has_effective_amount() const {
  return this != internal_default_instance() && effective_amount_ != nullptr;
}
inline bool SearchRequest::has_effective_amount() const {
  return _internal_has_effective_amount();
}
inline void SearchRequest::clear_effective_amount() {
  if (GetArena() == nullptr && effective_amount_ != nullptr) {
    delete effective_amount_;
  }
  effective_amount_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_effective_amount() const {
  const ::pb::RangeField* p = effective_amount_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::effective_amount() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.effective_amount)
  return _internal_effective_amount();
}
inline void SearchRequest::unsafe_arena_set_allocated_effective_amount(
    ::pb::RangeField* effective_amount) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(effective_amount_);
  }
  effective_amount_ = effective_amount;
  if (effective_amount) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.effective_amount)
}
inline ::pb::RangeField* SearchRequest::release_effective_amount() {
  
  ::pb::RangeField* temp = effective_amount_;
  effective_amount_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_effective_amount() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.effective_amount)
  
  ::pb::RangeField* temp = effective_amount_;
  effective_amount_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_effective_amount() {
  
  if (effective_amount_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    effective_amount_ = p;
  }
  return effective_amount_;
}
inline ::pb::RangeField* SearchRequest::mutable_effective_amount() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.effective_amount)
  return _internal_mutable_effective_amount();
}
inline void SearchRequest::set_allocated_effective_amount(::pb::RangeField* effective_amount) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete effective_amount_;
  }
  if (effective_amount) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(effective_amount);
    if (message_arena != submessage_arena) {
      effective_amount = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, effective_amount, submessage_arena);
    }
    
  } else {
    
  }
  effective_amount_ = effective_amount;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.effective_amount)
}

// .pb.RangeField support_amount = 38;
inline bool SearchRequest::_internal_has_support_amount() const {
  return this != internal_default_instance() && support_amount_ != nullptr;
}
inline bool SearchRequest::has_support_amount() const {
  return _internal_has_support_amount();
}
inline void SearchRequest::clear_support_amount() {
  if (GetArena() == nullptr && support_amount_ != nullptr) {
    delete support_amount_;
  }
  support_amount_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_support_amount() const {
  const ::pb::RangeField* p = support_amount_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::support_amount() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.support_amount)
  return _internal_support_amount();
}
inline void SearchRequest::unsafe_arena_set_allocated_support_amount(
    ::pb::RangeField* support_amount) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(support_amount_);
  }
  support_amount_ = support_amount;
  if (support_amount) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.support_amount)
}
inline ::pb::RangeField* SearchRequest::release_support_amount() {
  
  ::pb::RangeField* temp = support_amount_;
  support_amount_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_support_amount() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.support_amount)
  
  ::pb::RangeField* temp = support_amount_;
  support_amount_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_support_amount() {
  
  if (support_amount_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    support_amount_ = p;
  }
  return support_amount_;
}
inline ::pb::RangeField* SearchRequest::mutable_support_amount() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.support_amount)
  return _internal_mutable_support_amount();
}
inline void SearchRequest::set_allocated_support_amount(::pb::RangeField* support_amount) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete support_amount_;
  }
  if (support_amount) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(support_amount);
    if (message_arena != submessage_arena) {
      support_amount = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, support_amount, submessage_arena);
    }
    
  } else {
    
  }
  support_amount_ = support_amount;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.support_amount)
}

// .pb.RangeField trending_score = 39;
inline bool SearchRequest::_internal_has_trending_score() const {
  return this != internal_default_instance() && trending_score_ != nullptr;
}
inline bool SearchRequest::has_trending_score() const {
  return _internal_has_trending_score();
}
inline void SearchRequest::clear_trending_score() {
  if (GetArena() == nullptr && trending_score_ != nullptr) {
    delete trending_score_;
  }
  trending_score_ = nullptr;
}
inline const ::pb::RangeField& SearchRequest::_internal_trending_score() const {
  const ::pb::RangeField* p = trending_score_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::RangeField&>(
      ::pb::_RangeField_default_instance_);
}
inline const ::pb::RangeField& SearchRequest::trending_score() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.trending_score)
  return _internal_trending_score();
}
inline void SearchRequest::unsafe_arena_set_allocated_trending_score(
    ::pb::RangeField* trending_score) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(trending_score_);
  }
  trending_score_ = trending_score;
  if (trending_score) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.trending_score)
}
inline ::pb::RangeField* SearchRequest::release_trending_score() {
  
  ::pb::RangeField* temp = trending_score_;
  trending_score_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::RangeField* SearchRequest::unsafe_arena_release_trending_score() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.trending_score)
  
  ::pb::RangeField* temp = trending_score_;
  trending_score_ = nullptr;
  return temp;
}
inline ::pb::RangeField* SearchRequest::_internal_mutable_trending_score() {
  
  if (trending_score_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::RangeField>(GetArena());
    trending_score_ = p;
  }
  return trending_score_;
}
inline ::pb::RangeField* SearchRequest::mutable_trending_score() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.trending_score)
  return _internal_mutable_trending_score();
}
inline void SearchRequest::set_allocated_trending_score(::pb::RangeField* trending_score) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete trending_score_;
  }
  if (trending_score) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(trending_score);
    if (message_arena != submessage_arena) {
      trending_score = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, trending_score, submessage_arena);
    }
    
  } else {
    
  }
  trending_score_ = trending_score;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.trending_score)
}

// string tx_id = 43;
inline void SearchRequest::clear_tx_id() {
  tx_id_.ClearToEmpty();
}
inline const std::string& SearchRequest::tx_id() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.tx_id)
  return _internal_tx_id();
}
inline void SearchRequest::set_tx_id(const std::string& value) {
  _internal_set_tx_id(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.tx_id)
}
inline std::string* SearchRequest::mutable_tx_id() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.tx_id)
  return _internal_mutable_tx_id();
}
inline const std::string& SearchRequest::_internal_tx_id() const {
  return tx_id_.Get();
}
inline void SearchRequest::_internal_set_tx_id(const std::string& value) {
  
  tx_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_tx_id(std::string&& value) {
  
  tx_id_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.tx_id)
}
inline void SearchRequest::set_tx_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  tx_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.tx_id)
}
inline void SearchRequest::set_tx_id(const char* value,
    size_t size) {
  
  tx_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.tx_id)
}
inline std::string* SearchRequest::_internal_mutable_tx_id() {
  
  return tx_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_tx_id() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.tx_id)
  return tx_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_tx_id(std::string* tx_id) {
  if (tx_id != nullptr) {
    
  } else {
    
  }
  tx_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tx_id,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.tx_id)
}

// .pb.UInt32Value tx_nout = 44;
inline bool SearchRequest::_internal_has_tx_nout() const {
  return this != internal_default_instance() && tx_nout_ != nullptr;
}
inline bool SearchRequest::has_tx_nout() const {
  return _internal_has_tx_nout();
}
inline void SearchRequest::clear_tx_nout() {
  if (GetArena() == nullptr && tx_nout_ != nullptr) {
    delete tx_nout_;
  }
  tx_nout_ = nullptr;
}
inline const ::pb::UInt32Value& SearchRequest::_internal_tx_nout() const {
  const ::pb::UInt32Value* p = tx_nout_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::UInt32Value&>(
      ::pb::_UInt32Value_default_instance_);
}
inline const ::pb::UInt32Value& SearchRequest::tx_nout() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.tx_nout)
  return _internal_tx_nout();
}
inline void SearchRequest::unsafe_arena_set_allocated_tx_nout(
    ::pb::UInt32Value* tx_nout) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tx_nout_);
  }
  tx_nout_ = tx_nout;
  if (tx_nout) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.tx_nout)
}
inline ::pb::UInt32Value* SearchRequest::release_tx_nout() {
  
  ::pb::UInt32Value* temp = tx_nout_;
  tx_nout_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::UInt32Value* SearchRequest::unsafe_arena_release_tx_nout() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.tx_nout)
  
  ::pb::UInt32Value* temp = tx_nout_;
  tx_nout_ = nullptr;
  return temp;
}
inline ::pb::UInt32Value* SearchRequest::_internal_mutable_tx_nout() {
  
  if (tx_nout_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::UInt32Value>(GetArena());
    tx_nout_ = p;
  }
  return tx_nout_;
}
inline ::pb::UInt32Value* SearchRequest::mutable_tx_nout() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.tx_nout)
  return _internal_mutable_tx_nout();
}
inline void SearchRequest::set_allocated_tx_nout(::pb::UInt32Value* tx_nout) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete tx_nout_;
  }
  if (tx_nout) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(tx_nout);
    if (message_arena != submessage_arena) {
      tx_nout = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, tx_nout, submessage_arena);
    }
    
  } else {
    
  }
  tx_nout_ = tx_nout;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.tx_nout)
}

// string signature = 45;
inline void SearchRequest::clear_signature() {
  signature_.ClearToEmpty();
}
inline const std::string& SearchRequest::signature() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.signature)
  return _internal_signature();
}
inline void SearchRequest::set_signature(const std::string& value) {
  _internal_set_signature(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.signature)
}
inline std::string* SearchRequest::mutable_signature() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.signature)
  return _internal_mutable_signature();
}
inline const std::string& SearchRequest::_internal_signature() const {
  return signature_.Get();
}
inline void SearchRequest::_internal_set_signature(const std::string& value) {
  
  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_signature(std::string&& value) {
  
  signature_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.signature)
}
inline void SearchRequest::set_signature(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.signature)
}
inline void SearchRequest::set_signature(const char* value,
    size_t size) {
  
  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.signature)
}
inline std::string* SearchRequest::_internal_mutable_signature() {
  
  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_signature() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.signature)
  return signature_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_signature(std::string* signature) {
  if (signature != nullptr) {
    
  } else {
    
  }
  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.signature)
}

// string signature_digest = 46;
inline void SearchRequest::clear_signature_digest() {
  signature_digest_.ClearToEmpty();
}
inline const std::string& SearchRequest::signature_digest() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.signature_digest)
  return _internal_signature_digest();
}
inline void SearchRequest::set_signature_digest(const std::string& value) {
  _internal_set_signature_digest(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.signature_digest)
}
inline std::string* SearchRequest::mutable_signature_digest() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.signature_digest)
  return _internal_mutable_signature_digest();
}
inline const std::string& SearchRequest::_internal_signature_digest() const {
  return signature_digest_.Get();
}
inline void SearchRequest::_internal_set_signature_digest(const std::string& value) {
  
  signature_digest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_signature_digest(std::string&& value) {
  
  signature_digest_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.signature_digest)
}
inline void SearchRequest::set_signature_digest(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  signature_digest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.signature_digest)
}
inline void SearchRequest::set_signature_digest(const char* value,
    size_t size) {
  
  signature_digest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.signature_digest)
}
inline std::string* SearchRequest::_internal_mutable_signature_digest() {
  
  return signature_digest_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_signature_digest() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.signature_digest)
  return signature_digest_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_signature_digest(std::string* signature_digest) {
  if (signature_digest != nullptr) {
    
  } else {
    
  }
  signature_digest_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature_digest,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.signature_digest)
}

// string public_key_bytes = 47;
inline void SearchRequest::clear_public_key_bytes() {
  public_key_bytes_.ClearToEmpty();
}
inline const std::string& SearchRequest::public_key_bytes() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.public_key_bytes)
  return _internal_public_key_bytes();
}
inline void SearchRequest::set_public_key_bytes(const std::string& value) {
  _internal_set_public_key_bytes(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.public_key_bytes)
}
inline std::string* SearchRequest::mutable_public_key_bytes() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.public_key_bytes)
  return _internal_mutable_public_key_bytes();
}
inline const std::string& SearchRequest::_internal_public_key_bytes() const {
  return public_key_bytes_.Get();
}
inline void SearchRequest::_internal_set_public_key_bytes(const std::string& value) {
  
  public_key_bytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_public_key_bytes(std::string&& value) {
  
  public_key_bytes_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.public_key_bytes)
}
inline void SearchRequest::set_public_key_bytes(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  public_key_bytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.public_key_bytes)
}
inline void SearchRequest::set_public_key_bytes(const char* value,
    size_t size) {
  
  public_key_bytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.public_key_bytes)
}
inline std::string* SearchRequest::_internal_mutable_public_key_bytes() {
  
  return public_key_bytes_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_public_key_bytes() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.public_key_bytes)
  return public_key_bytes_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_public_key_bytes(std::string* public_key_bytes) {
  if (public_key_bytes != nullptr) {
    
  } else {
    
  }
  public_key_bytes_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), public_key_bytes,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.public_key_bytes)
}

// string public_key_id = 48;
inline void SearchRequest::clear_public_key_id() {
  public_key_id_.ClearToEmpty();
}
inline const std::string& SearchRequest::public_key_id() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.public_key_id)
  return _internal_public_key_id();
}
inline void SearchRequest::set_public_key_id(const std::string& value) {
  _internal_set_public_key_id(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.public_key_id)
}
inline std::string* SearchRequest::mutable_public_key_id() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.public_key_id)
  return _internal_mutable_public_key_id();
}
inline const std::string& SearchRequest::_internal_public_key_id() const {
  return public_key_id_.Get();
}
inline void SearchRequest::_internal_set_public_key_id(const std::string& value) {
  
  public_key_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void SearchRequest::set_public_key_id(std::string&& value) {
  
  public_key_id_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.SearchRequest.public_key_id)
}
inline void SearchRequest::set_public_key_id(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  public_key_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.public_key_id)
}
inline void SearchRequest::set_public_key_id(const char* value,
    size_t size) {
  
  public_key_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.public_key_id)
}
inline std::string* SearchRequest::_internal_mutable_public_key_id() {
  
  return public_key_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* SearchRequest::release_public_key_id() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.public_key_id)
  return public_key_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void SearchRequest::set_allocated_public_key_id(std::string* public_key_id) {
  if (public_key_id != nullptr) {
    
  } else {
    
  }
  public_key_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), public_key_id,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.public_key_id)
}

// repeated string any_tags = 49;
inline int SearchRequest::_internal_any_tags_size() const {
  return any_tags_.size();
}
inline int SearchRequest::any_tags_size() const {
  return _internal_any_tags_size();
}
inline void SearchRequest::clear_any_tags() {
  any_tags_.Clear();
}
inline std::string* SearchRequest::add_any_tags() {
  // @@protoc_insertion_point(field_add_mutable:pb.SearchRequest.any_tags)
  return _internal_add_any_tags();
}
inline const std::string& SearchRequest::_internal_any_tags(int index) const {
  return any_tags_.Get(index);
}
inline const std::string& SearchRequest::any_tags(int index) const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.any_tags)
  return _internal_any_tags(index);
}
inline std::string* SearchRequest::mutable_any_tags(int index) {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.any_tags)
  return any_tags_.Mutable(index);
}
inline void SearchRequest::set_any_tags(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.any_tags)
  any_tags_.Mutable(index)->assign(value);
}
inline void SearchRequest::set_any_tags(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.any_tags)
  any_tags_.Mutable(index)->assign(std::move(value));
}
inline void SearchRequest::set_any_tags(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  any_tags_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.any_tags)
}
inline void SearchRequest::set_any_tags(int index, const char* value, size_t size) {
  any_tags_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.any_tags)
}
inline std::string* SearchRequest::_internal_add_any_tags() {
  return any_tags_.Add();
}
inline void SearchRequest::add_any_tags(const std::string& value) {
  any_tags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:pb.SearchRequest.any_tags)
}
inline void SearchRequest::add_any_tags(std::string&& value) {
  any_tags_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:pb.SearchRequest.any_tags)
}
inline void SearchRequest::add_any_tags(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  any_tags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:pb.SearchRequest.any_tags)
}
inline void SearchRequest::add_any_tags(const char* value, size_t size) {
  any_tags_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:pb.SearchRequest.any_tags)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchRequest::any_tags() const {
  // @@protoc_insertion_point(field_list:pb.SearchRequest.any_tags)
  return any_tags_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchRequest::mutable_any_tags() {
  // @@protoc_insertion_point(field_mutable_list:pb.SearchRequest.any_tags)
  return &any_tags_;
}

// repeated string all_tags = 50;
inline int SearchRequest::_internal_all_tags_size() const {
  return all_tags_.size();
}
inline int SearchRequest::all_tags_size() const {
  return _internal_all_tags_size();
}
inline void SearchRequest::clear_all_tags() {
  all_tags_.Clear();
}
inline std::string* SearchRequest::add_all_tags() {
  // @@protoc_insertion_point(field_add_mutable:pb.SearchRequest.all_tags)
  return _internal_add_all_tags();
}
inline const std::string& SearchRequest::_internal_all_tags(int index) const {
  return all_tags_.Get(index);
}
inline const std::string& SearchRequest::all_tags(int index) const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.all_tags)
  return _internal_all_tags(index);
}
inline std::string* SearchRequest::mutable_all_tags(int index) {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.all_tags)
  return all_tags_.Mutable(index);
}
inline void SearchRequest::set_all_tags(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.all_tags)
  all_tags_.Mutable(index)->assign(value);
}
inline void SearchRequest::set_all_tags(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.all_tags)
  all_tags_.Mutable(index)->assign(std::move(value));
}
inline void SearchRequest::set_all_tags(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  all_tags_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.all_tags)
}
inline void SearchRequest::set_all_tags(int index, const char* value, size_t size) {
  all_tags_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.all_tags)
}
inline std::string* SearchRequest::_internal_add_all_tags() {
  return all_tags_.Add();
}
inline void SearchRequest::add_all_tags(const std::string& value) {
  all_tags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:pb.SearchRequest.all_tags)
}
inline void SearchRequest::add_all_tags(std::string&& value) {
  all_tags_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:pb.SearchRequest.all_tags)
}
inline void SearchRequest::add_all_tags(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  all_tags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:pb.SearchRequest.all_tags)
}
inline void SearchRequest::add_all_tags(const char* value, size_t size) {
  all_tags_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:pb.SearchRequest.all_tags)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchRequest::all_tags() const {
  // @@protoc_insertion_point(field_list:pb.SearchRequest.all_tags)
  return all_tags_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchRequest::mutable_all_tags() {
  // @@protoc_insertion_point(field_mutable_list:pb.SearchRequest.all_tags)
  return &all_tags_;
}

// repeated string not_tags = 51;
inline int SearchRequest::_internal_not_tags_size() const {
  return not_tags_.size();
}
inline int SearchRequest::not_tags_size() const {
  return _internal_not_tags_size();
}
inline void SearchRequest::clear_not_tags() {
  not_tags_.Clear();
}
inline std::string* SearchRequest::add_not_tags() {
  // @@protoc_insertion_point(field_add_mutable:pb.SearchRequest.not_tags)
  return _internal_add_not_tags();
}
inline const std::string& SearchRequest::_internal_not_tags(int index) const {
  return not_tags_.Get(index);
}
inline const std::string& SearchRequest::not_tags(int index) const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.not_tags)
  return _internal_not_tags(index);
}
inline std::string* SearchRequest::mutable_not_tags(int index) {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.not_tags)
  return not_tags_.Mutable(index);
}
inline void SearchRequest::set_not_tags(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.not_tags)
  not_tags_.Mutable(index)->assign(value);
}
inline void SearchRequest::set_not_tags(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.not_tags)
  not_tags_.Mutable(index)->assign(std::move(value));
}
inline void SearchRequest::set_not_tags(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  not_tags_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.not_tags)
}
inline void SearchRequest::set_not_tags(int index, const char* value, size_t size) {
  not_tags_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.not_tags)
}
inline std::string* SearchRequest::_internal_add_not_tags() {
  return not_tags_.Add();
}
inline void SearchRequest::add_not_tags(const std::string& value) {
  not_tags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:pb.SearchRequest.not_tags)
}
inline void SearchRequest::add_not_tags(std::string&& value) {
  not_tags_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:pb.SearchRequest.not_tags)
}
inline void SearchRequest::add_not_tags(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  not_tags_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:pb.SearchRequest.not_tags)
}
inline void SearchRequest::add_not_tags(const char* value, size_t size) {
  not_tags_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:pb.SearchRequest.not_tags)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchRequest::not_tags() const {
  // @@protoc_insertion_point(field_list:pb.SearchRequest.not_tags)
  return not_tags_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchRequest::mutable_not_tags() {
  // @@protoc_insertion_point(field_mutable_list:pb.SearchRequest.not_tags)
  return &not_tags_;
}

// bool has_channel_signature = 52;
inline void SearchRequest::clear_has_channel_signature() {
  has_channel_signature_ = false;
}
inline bool SearchRequest::_internal_has_channel_signature() const {
  return has_channel_signature_;
}
inline bool SearchRequest::has_channel_signature() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.has_channel_signature)
  return _internal_has_channel_signature();
}
inline void SearchRequest::_internal_set_has_channel_signature(bool value) {
  
  has_channel_signature_ = value;
}
inline void SearchRequest::set_has_channel_signature(bool value) {
  _internal_set_has_channel_signature(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.has_channel_signature)
}

// .pb.BoolValue has_source = 53;
inline bool SearchRequest::_internal_has_has_source() const {
  return this != internal_default_instance() && has_source_ != nullptr;
}
inline bool SearchRequest::has_has_source() const {
  return _internal_has_has_source();
}
inline void SearchRequest::clear_has_source() {
  if (GetArena() == nullptr && has_source_ != nullptr) {
    delete has_source_;
  }
  has_source_ = nullptr;
}
inline const ::pb::BoolValue& SearchRequest::_internal_has_source() const {
  const ::pb::BoolValue* p = has_source_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::BoolValue&>(
      ::pb::_BoolValue_default_instance_);
}
inline const ::pb::BoolValue& SearchRequest::has_source() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.has_source)
  return _internal_has_source();
}
inline void SearchRequest::unsafe_arena_set_allocated_has_source(
    ::pb::BoolValue* has_source) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(has_source_);
  }
  has_source_ = has_source;
  if (has_source) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.SearchRequest.has_source)
}
inline ::pb::BoolValue* SearchRequest::release_has_source() {
  
  ::pb::BoolValue* temp = has_source_;
  has_source_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::BoolValue* SearchRequest::unsafe_arena_release_has_source() {
  // @@protoc_insertion_point(field_release:pb.SearchRequest.has_source)
  
  ::pb::BoolValue* temp = has_source_;
  has_source_ = nullptr;
  return temp;
}
inline ::pb::BoolValue* SearchRequest::_internal_mutable_has_source() {
  
  if (has_source_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::BoolValue>(GetArena());
    has_source_ = p;
  }
  return has_source_;
}
inline ::pb::BoolValue* SearchRequest::mutable_has_source() {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.has_source)
  return _internal_mutable_has_source();
}
inline void SearchRequest::set_allocated_has_source(::pb::BoolValue* has_source) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete has_source_;
  }
  if (has_source) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(has_source);
    if (message_arena != submessage_arena) {
      has_source = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, has_source, submessage_arena);
    }
    
  } else {
    
  }
  has_source_ = has_source;
  // @@protoc_insertion_point(field_set_allocated:pb.SearchRequest.has_source)
}

// uint32 limit_claims_per_channel = 54;
inline void SearchRequest::clear_limit_claims_per_channel() {
  limit_claims_per_channel_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SearchRequest::_internal_limit_claims_per_channel() const {
  return limit_claims_per_channel_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 SearchRequest::limit_claims_per_channel() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.limit_claims_per_channel)
  return _internal_limit_claims_per_channel();
}
inline void SearchRequest::_internal_set_limit_claims_per_channel(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  limit_claims_per_channel_ = value;
}
inline void SearchRequest::set_limit_claims_per_channel(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_limit_claims_per_channel(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.limit_claims_per_channel)
}

// repeated string any_languages = 55;
inline int SearchRequest::_internal_any_languages_size() const {
  return any_languages_.size();
}
inline int SearchRequest::any_languages_size() const {
  return _internal_any_languages_size();
}
inline void SearchRequest::clear_any_languages() {
  any_languages_.Clear();
}
inline std::string* SearchRequest::add_any_languages() {
  // @@protoc_insertion_point(field_add_mutable:pb.SearchRequest.any_languages)
  return _internal_add_any_languages();
}
inline const std::string& SearchRequest::_internal_any_languages(int index) const {
  return any_languages_.Get(index);
}
inline const std::string& SearchRequest::any_languages(int index) const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.any_languages)
  return _internal_any_languages(index);
}
inline std::string* SearchRequest::mutable_any_languages(int index) {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.any_languages)
  return any_languages_.Mutable(index);
}
inline void SearchRequest::set_any_languages(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.any_languages)
  any_languages_.Mutable(index)->assign(value);
}
inline void SearchRequest::set_any_languages(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.any_languages)
  any_languages_.Mutable(index)->assign(std::move(value));
}
inline void SearchRequest::set_any_languages(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  any_languages_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.any_languages)
}
inline void SearchRequest::set_any_languages(int index, const char* value, size_t size) {
  any_languages_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.any_languages)
}
inline std::string* SearchRequest::_internal_add_any_languages() {
  return any_languages_.Add();
}
inline void SearchRequest::add_any_languages(const std::string& value) {
  any_languages_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:pb.SearchRequest.any_languages)
}
inline void SearchRequest::add_any_languages(std::string&& value) {
  any_languages_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:pb.SearchRequest.any_languages)
}
inline void SearchRequest::add_any_languages(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  any_languages_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:pb.SearchRequest.any_languages)
}
inline void SearchRequest::add_any_languages(const char* value, size_t size) {
  any_languages_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:pb.SearchRequest.any_languages)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchRequest::any_languages() const {
  // @@protoc_insertion_point(field_list:pb.SearchRequest.any_languages)
  return any_languages_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchRequest::mutable_any_languages() {
  // @@protoc_insertion_point(field_mutable_list:pb.SearchRequest.any_languages)
  return &any_languages_;
}

// repeated string all_languages = 56;
inline int SearchRequest::_internal_all_languages_size() const {
  return all_languages_.size();
}
inline int SearchRequest::all_languages_size() const {
  return _internal_all_languages_size();
}
inline void SearchRequest::clear_all_languages() {
  all_languages_.Clear();
}
inline std::string* SearchRequest::add_all_languages() {
  // @@protoc_insertion_point(field_add_mutable:pb.SearchRequest.all_languages)
  return _internal_add_all_languages();
}
inline const std::string& SearchRequest::_internal_all_languages(int index) const {
  return all_languages_.Get(index);
}
inline const std::string& SearchRequest::all_languages(int index) const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.all_languages)
  return _internal_all_languages(index);
}
inline std::string* SearchRequest::mutable_all_languages(int index) {
  // @@protoc_insertion_point(field_mutable:pb.SearchRequest.all_languages)
  return all_languages_.Mutable(index);
}
inline void SearchRequest::set_all_languages(int index, const std::string& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.all_languages)
  all_languages_.Mutable(index)->assign(value);
}
inline void SearchRequest::set_all_languages(int index, std::string&& value) {
  // @@protoc_insertion_point(field_set:pb.SearchRequest.all_languages)
  all_languages_.Mutable(index)->assign(std::move(value));
}
inline void SearchRequest::set_all_languages(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  all_languages_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:pb.SearchRequest.all_languages)
}
inline void SearchRequest::set_all_languages(int index, const char* value, size_t size) {
  all_languages_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:pb.SearchRequest.all_languages)
}
inline std::string* SearchRequest::_internal_add_all_languages() {
  return all_languages_.Add();
}
inline void SearchRequest::add_all_languages(const std::string& value) {
  all_languages_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:pb.SearchRequest.all_languages)
}
inline void SearchRequest::add_all_languages(std::string&& value) {
  all_languages_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:pb.SearchRequest.all_languages)
}
inline void SearchRequest::add_all_languages(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  all_languages_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:pb.SearchRequest.all_languages)
}
inline void SearchRequest::add_all_languages(const char* value, size_t size) {
  all_languages_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:pb.SearchRequest.all_languages)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
SearchRequest::all_languages() const {
  // @@protoc_insertion_point(field_list:pb.SearchRequest.all_languages)
  return all_languages_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
SearchRequest::mutable_all_languages() {
  // @@protoc_insertion_point(field_mutable_list:pb.SearchRequest.all_languages)
  return &all_languages_;
}

// bool remove_duplicates = 57;
inline void SearchRequest::clear_remove_duplicates() {
  remove_duplicates_ = false;
}
inline bool SearchRequest::_internal_remove_duplicates() const {
  return remove_duplicates_;
}
inline bool SearchRequest::remove_duplicates() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.remove_duplicates)
  return _internal_remove_duplicates();
}
inline void SearchRequest::_internal_set_remove_duplicates(bool value) {
  
  remove_duplicates_ = value;
}
inline void SearchRequest::set_remove_duplicates(bool value) {
  _internal_set_remove_duplicates(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.remove_duplicates)
}

// bool no_totals = 58;
inline void SearchRequest::clear_no_totals() {
  no_totals_ = false;
}
inline bool SearchRequest::_internal_no_totals() const {
  return no_totals_;
}
inline bool SearchRequest::no_totals() const {
  // @@protoc_insertion_point(field_get:pb.SearchRequest.no_totals)
  return _internal_no_totals();
}
inline void SearchRequest::_internal_set_no_totals(bool value) {
  
  no_totals_ = value;
}
inline void SearchRequest::set_no_totals(bool value) {
  _internal_set_no_totals(value);
  // @@protoc_insertion_point(field_set:pb.SearchRequest.no_totals)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace pb

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::pb::RangeField_Op> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::pb::RangeField_Op>() {
  return ::pb::RangeField_Op_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_hub_2eproto