types/v2/cpp/result.pb.h

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

#ifndef GOOGLE_PROTOBUF_INCLUDED_result_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_result_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>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_result_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_result_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_result_2eproto;
::PROTOBUF_NAMESPACE_ID::Metadata descriptor_table_result_2eproto_metadata_getter(int index);
namespace pb {
class Blocked;
struct BlockedDefaultTypeInternal;
extern BlockedDefaultTypeInternal _Blocked_default_instance_;
class ClaimMeta;
struct ClaimMetaDefaultTypeInternal;
extern ClaimMetaDefaultTypeInternal _ClaimMeta_default_instance_;
class Error;
struct ErrorDefaultTypeInternal;
extern ErrorDefaultTypeInternal _Error_default_instance_;
class Output;
struct OutputDefaultTypeInternal;
extern OutputDefaultTypeInternal _Output_default_instance_;
class Outputs;
struct OutputsDefaultTypeInternal;
extern OutputsDefaultTypeInternal _Outputs_default_instance_;
}  // namespace pb
PROTOBUF_NAMESPACE_OPEN
template<> ::pb::Blocked* Arena::CreateMaybeMessage<::pb::Blocked>(Arena*);
template<> ::pb::ClaimMeta* Arena::CreateMaybeMessage<::pb::ClaimMeta>(Arena*);
template<> ::pb::Error* Arena::CreateMaybeMessage<::pb::Error>(Arena*);
template<> ::pb::Output* Arena::CreateMaybeMessage<::pb::Output>(Arena*);
template<> ::pb::Outputs* Arena::CreateMaybeMessage<::pb::Outputs>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace pb {

enum Error_Code : int {
  Error_Code_UNKNOWN_CODE = 0,
  Error_Code_NOT_FOUND = 1,
  Error_Code_INVALID = 2,
  Error_Code_BLOCKED = 3,
  Error_Code_Error_Code_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  Error_Code_Error_Code_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool Error_Code_IsValid(int value);
constexpr Error_Code Error_Code_Code_MIN = Error_Code_UNKNOWN_CODE;
constexpr Error_Code Error_Code_Code_MAX = Error_Code_BLOCKED;
constexpr int Error_Code_Code_ARRAYSIZE = Error_Code_Code_MAX + 1;

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

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

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

  inline Outputs& operator=(const Outputs& from) {
    CopyFrom(from);
    return *this;
  }
  inline Outputs& operator=(Outputs&& 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 Outputs& default_instance() {
    return *internal_default_instance();
  }
  static inline const Outputs* internal_default_instance() {
    return reinterpret_cast<const Outputs*>(
               &_Outputs_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

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

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

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

  Outputs* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Outputs>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Outputs& from);
  void MergeFrom(const Outputs& 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(Outputs* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.Outputs";
  }
  protected:
  explicit Outputs(::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_result_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

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

  enum : int {
    kTxosFieldNumber = 1,
    kExtraTxosFieldNumber = 2,
    kBlockedFieldNumber = 5,
    kTotalFieldNumber = 3,
    kOffsetFieldNumber = 4,
    kBlockedTotalFieldNumber = 6,
  };
  // repeated .pb.Output txos = 1;
  int txos_size() const;
  private:
  int _internal_txos_size() const;
  public:
  void clear_txos();
  ::pb::Output* mutable_txos(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output >*
      mutable_txos();
  private:
  const ::pb::Output& _internal_txos(int index) const;
  ::pb::Output* _internal_add_txos();
  public:
  const ::pb::Output& txos(int index) const;
  ::pb::Output* add_txos();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output >&
      txos() const;

  // repeated .pb.Output extra_txos = 2;
  int extra_txos_size() const;
  private:
  int _internal_extra_txos_size() const;
  public:
  void clear_extra_txos();
  ::pb::Output* mutable_extra_txos(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output >*
      mutable_extra_txos();
  private:
  const ::pb::Output& _internal_extra_txos(int index) const;
  ::pb::Output* _internal_add_extra_txos();
  public:
  const ::pb::Output& extra_txos(int index) const;
  ::pb::Output* add_extra_txos();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output >&
      extra_txos() const;

  // repeated .pb.Blocked blocked = 5;
  int blocked_size() const;
  private:
  int _internal_blocked_size() const;
  public:
  void clear_blocked();
  ::pb::Blocked* mutable_blocked(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Blocked >*
      mutable_blocked();
  private:
  const ::pb::Blocked& _internal_blocked(int index) const;
  ::pb::Blocked* _internal_add_blocked();
  public:
  const ::pb::Blocked& blocked(int index) const;
  ::pb::Blocked* add_blocked();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Blocked >&
      blocked() const;

  // uint32 total = 3;
  void clear_total();
  ::PROTOBUF_NAMESPACE_ID::uint32 total() const;
  void set_total(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_total() const;
  void _internal_set_total(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 offset = 4;
  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:

  // uint32 blocked_total = 6;
  void clear_blocked_total();
  ::PROTOBUF_NAMESPACE_ID::uint32 blocked_total() const;
  void set_blocked_total(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_blocked_total() const;
  void _internal_set_blocked_total(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output > txos_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output > extra_txos_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Blocked > blocked_;
  ::PROTOBUF_NAMESPACE_ID::uint32 total_;
  ::PROTOBUF_NAMESPACE_ID::uint32 offset_;
  ::PROTOBUF_NAMESPACE_ID::uint32 blocked_total_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_result_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline Output& operator=(const Output& from) {
    CopyFrom(from);
    return *this;
  }
  inline Output& operator=(Output&& 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 Output& default_instance() {
    return *internal_default_instance();
  }
  enum MetaCase {
    kClaim = 7,
    kError = 15,
    META_NOT_SET = 0,
  };

  static inline const Output* internal_default_instance() {
    return reinterpret_cast<const Output*>(
               &_Output_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

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

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

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

  Output* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Output>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Output& from);
  void MergeFrom(const Output& 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(Output* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.Output";
  }
  protected:
  explicit Output(::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_result_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

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

  enum : int {
    kTxHashFieldNumber = 1,
    kNoutFieldNumber = 2,
    kHeightFieldNumber = 3,
    kClaimFieldNumber = 7,
    kErrorFieldNumber = 15,
  };
  // bytes tx_hash = 1;
  void clear_tx_hash();
  const std::string& tx_hash() const;
  void set_tx_hash(const std::string& value);
  void set_tx_hash(std::string&& value);
  void set_tx_hash(const char* value);
  void set_tx_hash(const void* value, size_t size);
  std::string* mutable_tx_hash();
  std::string* release_tx_hash();
  void set_allocated_tx_hash(std::string* tx_hash);
  private:
  const std::string& _internal_tx_hash() const;
  void _internal_set_tx_hash(const std::string& value);
  std::string* _internal_mutable_tx_hash();
  public:

  // uint32 nout = 2;
  void clear_nout();
  ::PROTOBUF_NAMESPACE_ID::uint32 nout() const;
  void set_nout(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_nout() const;
  void _internal_set_nout(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 height = 3;
  void clear_height();
  ::PROTOBUF_NAMESPACE_ID::uint32 height() const;
  void set_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_height() const;
  void _internal_set_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // .pb.ClaimMeta claim = 7;
  bool has_claim() const;
  private:
  bool _internal_has_claim() const;
  public:
  void clear_claim();
  const ::pb::ClaimMeta& claim() const;
  ::pb::ClaimMeta* release_claim();
  ::pb::ClaimMeta* mutable_claim();
  void set_allocated_claim(::pb::ClaimMeta* claim);
  private:
  const ::pb::ClaimMeta& _internal_claim() const;
  ::pb::ClaimMeta* _internal_mutable_claim();
  public:
  void unsafe_arena_set_allocated_claim(
      ::pb::ClaimMeta* claim);
  ::pb::ClaimMeta* unsafe_arena_release_claim();

  // .pb.Error error = 15;
  bool has_error() const;
  private:
  bool _internal_has_error() const;
  public:
  void clear_error();
  const ::pb::Error& error() const;
  ::pb::Error* release_error();
  ::pb::Error* mutable_error();
  void set_allocated_error(::pb::Error* error);
  private:
  const ::pb::Error& _internal_error() const;
  ::pb::Error* _internal_mutable_error();
  public:
  void unsafe_arena_set_allocated_error(
      ::pb::Error* error);
  ::pb::Error* unsafe_arena_release_error();

  void clear_meta();
  MetaCase meta_case() const;
  // @@protoc_insertion_point(class_scope:pb.Output)
 private:
  class _Internal;
  void set_has_claim();
  void set_has_error();

  inline bool has_meta() const;
  inline void clear_has_meta();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tx_hash_;
  ::PROTOBUF_NAMESPACE_ID::uint32 nout_;
  ::PROTOBUF_NAMESPACE_ID::uint32 height_;
  union MetaUnion {
    constexpr MetaUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::pb::ClaimMeta* claim_;
    ::pb::Error* error_;
  } meta_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_result_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline ClaimMeta& operator=(const ClaimMeta& from) {
    CopyFrom(from);
    return *this;
  }
  inline ClaimMeta& operator=(ClaimMeta&& 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 ClaimMeta& default_instance() {
    return *internal_default_instance();
  }
  static inline const ClaimMeta* internal_default_instance() {
    return reinterpret_cast<const ClaimMeta*>(
               &_ClaimMeta_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

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

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

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

  ClaimMeta* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ClaimMeta>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ClaimMeta& from);
  void MergeFrom(const ClaimMeta& 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(ClaimMeta* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.ClaimMeta";
  }
  protected:
  explicit ClaimMeta(::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_result_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

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

  enum : int {
    kShortUrlFieldNumber = 3,
    kCanonicalUrlFieldNumber = 4,
    kChannelFieldNumber = 1,
    kRepostFieldNumber = 2,
    kIsControllingFieldNumber = 5,
    kTakeOverHeightFieldNumber = 6,
    kCreationHeightFieldNumber = 7,
    kActivationHeightFieldNumber = 8,
    kExpirationHeightFieldNumber = 9,
    kClaimsInChannelFieldNumber = 10,
    kRepostedFieldNumber = 11,
    kEffectiveAmountFieldNumber = 20,
    kSupportAmountFieldNumber = 21,
    kTrendingScoreFieldNumber = 22,
  };
  // string short_url = 3;
  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 = 4;
  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:

  // .pb.Output channel = 1;
  bool has_channel() const;
  private:
  bool _internal_has_channel() const;
  public:
  void clear_channel();
  const ::pb::Output& channel() const;
  ::pb::Output* release_channel();
  ::pb::Output* mutable_channel();
  void set_allocated_channel(::pb::Output* channel);
  private:
  const ::pb::Output& _internal_channel() const;
  ::pb::Output* _internal_mutable_channel();
  public:
  void unsafe_arena_set_allocated_channel(
      ::pb::Output* channel);
  ::pb::Output* unsafe_arena_release_channel();

  // .pb.Output repost = 2;
  bool has_repost() const;
  private:
  bool _internal_has_repost() const;
  public:
  void clear_repost();
  const ::pb::Output& repost() const;
  ::pb::Output* release_repost();
  ::pb::Output* mutable_repost();
  void set_allocated_repost(::pb::Output* repost);
  private:
  const ::pb::Output& _internal_repost() const;
  ::pb::Output* _internal_mutable_repost();
  public:
  void unsafe_arena_set_allocated_repost(
      ::pb::Output* repost);
  ::pb::Output* unsafe_arena_release_repost();

  // bool is_controlling = 5;
  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:

  // uint32 take_over_height = 6;
  void clear_take_over_height();
  ::PROTOBUF_NAMESPACE_ID::uint32 take_over_height() const;
  void set_take_over_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_take_over_height() const;
  void _internal_set_take_over_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 creation_height = 7;
  void clear_creation_height();
  ::PROTOBUF_NAMESPACE_ID::uint32 creation_height() const;
  void set_creation_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_creation_height() const;
  void _internal_set_creation_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 activation_height = 8;
  void clear_activation_height();
  ::PROTOBUF_NAMESPACE_ID::uint32 activation_height() const;
  void set_activation_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_activation_height() const;
  void _internal_set_activation_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 expiration_height = 9;
  void clear_expiration_height();
  ::PROTOBUF_NAMESPACE_ID::uint32 expiration_height() const;
  void set_expiration_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_expiration_height() const;
  void _internal_set_expiration_height(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 claims_in_channel = 10;
  void clear_claims_in_channel();
  ::PROTOBUF_NAMESPACE_ID::uint32 claims_in_channel() const;
  void set_claims_in_channel(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_claims_in_channel() const;
  void _internal_set_claims_in_channel(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 reposted = 11;
  void clear_reposted();
  ::PROTOBUF_NAMESPACE_ID::uint32 reposted() const;
  void set_reposted(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_reposted() const;
  void _internal_set_reposted(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint64 effective_amount = 20;
  void clear_effective_amount();
  ::PROTOBUF_NAMESPACE_ID::uint64 effective_amount() const;
  void set_effective_amount(::PROTOBUF_NAMESPACE_ID::uint64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_effective_amount() const;
  void _internal_set_effective_amount(::PROTOBUF_NAMESPACE_ID::uint64 value);
  public:

  // uint64 support_amount = 21;
  void clear_support_amount();
  ::PROTOBUF_NAMESPACE_ID::uint64 support_amount() const;
  void set_support_amount(::PROTOBUF_NAMESPACE_ID::uint64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_support_amount() const;
  void _internal_set_support_amount(::PROTOBUF_NAMESPACE_ID::uint64 value);
  public:

  // double trending_score = 22;
  void clear_trending_score();
  double trending_score() const;
  void set_trending_score(double value);
  private:
  double _internal_trending_score() const;
  void _internal_set_trending_score(double value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr short_url_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr canonical_url_;
  ::pb::Output* channel_;
  ::pb::Output* repost_;
  bool is_controlling_;
  ::PROTOBUF_NAMESPACE_ID::uint32 take_over_height_;
  ::PROTOBUF_NAMESPACE_ID::uint32 creation_height_;
  ::PROTOBUF_NAMESPACE_ID::uint32 activation_height_;
  ::PROTOBUF_NAMESPACE_ID::uint32 expiration_height_;
  ::PROTOBUF_NAMESPACE_ID::uint32 claims_in_channel_;
  ::PROTOBUF_NAMESPACE_ID::uint32 reposted_;
  ::PROTOBUF_NAMESPACE_ID::uint64 effective_amount_;
  ::PROTOBUF_NAMESPACE_ID::uint64 support_amount_;
  double trending_score_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_result_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline Error& operator=(const Error& from) {
    CopyFrom(from);
    return *this;
  }
  inline Error& operator=(Error&& 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 Error& default_instance() {
    return *internal_default_instance();
  }
  static inline const Error* internal_default_instance() {
    return reinterpret_cast<const Error*>(
               &_Error_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

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

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

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

  Error* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Error>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Error& from);
  void MergeFrom(const Error& 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(Error* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.Error";
  }
  protected:
  explicit Error(::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_result_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

  typedef Error_Code Code;
  static constexpr Code UNKNOWN_CODE =
    Error_Code_UNKNOWN_CODE;
  static constexpr Code NOT_FOUND =
    Error_Code_NOT_FOUND;
  static constexpr Code INVALID =
    Error_Code_INVALID;
  static constexpr Code BLOCKED =
    Error_Code_BLOCKED;
  static inline bool Code_IsValid(int value) {
    return Error_Code_IsValid(value);
  }
  static constexpr Code Code_MIN =
    Error_Code_Code_MIN;
  static constexpr Code Code_MAX =
    Error_Code_Code_MAX;
  static constexpr int Code_ARRAYSIZE =
    Error_Code_Code_ARRAYSIZE;
  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
  Code_descriptor() {
    return Error_Code_descriptor();
  }
  template<typename T>
  static inline const std::string& Code_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Code>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Code_Name.");
    return Error_Code_Name(enum_t_value);
  }
  static inline bool Code_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
      Code* value) {
    return Error_Code_Parse(name, value);
  }

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

  enum : int {
    kTextFieldNumber = 2,
    kBlockedFieldNumber = 3,
    kCodeFieldNumber = 1,
  };
  // string text = 2;
  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:

  // .pb.Blocked blocked = 3;
  bool has_blocked() const;
  private:
  bool _internal_has_blocked() const;
  public:
  void clear_blocked();
  const ::pb::Blocked& blocked() const;
  ::pb::Blocked* release_blocked();
  ::pb::Blocked* mutable_blocked();
  void set_allocated_blocked(::pb::Blocked* blocked);
  private:
  const ::pb::Blocked& _internal_blocked() const;
  ::pb::Blocked* _internal_mutable_blocked();
  public:
  void unsafe_arena_set_allocated_blocked(
      ::pb::Blocked* blocked);
  ::pb::Blocked* unsafe_arena_release_blocked();

  // .pb.Error.Code code = 1;
  void clear_code();
  ::pb::Error_Code code() const;
  void set_code(::pb::Error_Code value);
  private:
  ::pb::Error_Code _internal_code() const;
  void _internal_set_code(::pb::Error_Code value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
  ::pb::Blocked* blocked_;
  int code_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_result_2eproto;
};
// -------------------------------------------------------------------

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

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

  inline Blocked& operator=(const Blocked& from) {
    CopyFrom(from);
    return *this;
  }
  inline Blocked& operator=(Blocked&& 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 Blocked& default_instance() {
    return *internal_default_instance();
  }
  static inline const Blocked* internal_default_instance() {
    return reinterpret_cast<const Blocked*>(
               &_Blocked_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

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

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

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

  Blocked* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Blocked>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Blocked& from);
  void MergeFrom(const Blocked& 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(Blocked* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "pb.Blocked";
  }
  protected:
  explicit Blocked(::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_result_2eproto_metadata_getter(kIndexInFileMessages);
  }

  public:

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

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

  enum : int {
    kChannelFieldNumber = 2,
    kCountFieldNumber = 1,
  };
  // .pb.Output channel = 2;
  bool has_channel() const;
  private:
  bool _internal_has_channel() const;
  public:
  void clear_channel();
  const ::pb::Output& channel() const;
  ::pb::Output* release_channel();
  ::pb::Output* mutable_channel();
  void set_allocated_channel(::pb::Output* channel);
  private:
  const ::pb::Output& _internal_channel() const;
  ::pb::Output* _internal_mutable_channel();
  public:
  void unsafe_arena_set_allocated_channel(
      ::pb::Output* channel);
  ::pb::Output* unsafe_arena_release_channel();

  // uint32 count = 1;
  void clear_count();
  ::PROTOBUF_NAMESPACE_ID::uint32 count() const;
  void set_count(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_count() const;
  void _internal_set_count(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

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

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::pb::Output* channel_;
  ::PROTOBUF_NAMESPACE_ID::uint32 count_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_result_2eproto;
};
// ===================================================================


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

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

// repeated .pb.Output txos = 1;
inline int Outputs::_internal_txos_size() const {
  return txos_.size();
}
inline int Outputs::txos_size() const {
  return _internal_txos_size();
}
inline void Outputs::clear_txos() {
  txos_.Clear();
}
inline ::pb::Output* Outputs::mutable_txos(int index) {
  // @@protoc_insertion_point(field_mutable:pb.Outputs.txos)
  return txos_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output >*
Outputs::mutable_txos() {
  // @@protoc_insertion_point(field_mutable_list:pb.Outputs.txos)
  return &txos_;
}
inline const ::pb::Output& Outputs::_internal_txos(int index) const {
  return txos_.Get(index);
}
inline const ::pb::Output& Outputs::txos(int index) const {
  // @@protoc_insertion_point(field_get:pb.Outputs.txos)
  return _internal_txos(index);
}
inline ::pb::Output* Outputs::_internal_add_txos() {
  return txos_.Add();
}
inline ::pb::Output* Outputs::add_txos() {
  // @@protoc_insertion_point(field_add:pb.Outputs.txos)
  return _internal_add_txos();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output >&
Outputs::txos() const {
  // @@protoc_insertion_point(field_list:pb.Outputs.txos)
  return txos_;
}

// repeated .pb.Output extra_txos = 2;
inline int Outputs::_internal_extra_txos_size() const {
  return extra_txos_.size();
}
inline int Outputs::extra_txos_size() const {
  return _internal_extra_txos_size();
}
inline void Outputs::clear_extra_txos() {
  extra_txos_.Clear();
}
inline ::pb::Output* Outputs::mutable_extra_txos(int index) {
  // @@protoc_insertion_point(field_mutable:pb.Outputs.extra_txos)
  return extra_txos_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output >*
Outputs::mutable_extra_txos() {
  // @@protoc_insertion_point(field_mutable_list:pb.Outputs.extra_txos)
  return &extra_txos_;
}
inline const ::pb::Output& Outputs::_internal_extra_txos(int index) const {
  return extra_txos_.Get(index);
}
inline const ::pb::Output& Outputs::extra_txos(int index) const {
  // @@protoc_insertion_point(field_get:pb.Outputs.extra_txos)
  return _internal_extra_txos(index);
}
inline ::pb::Output* Outputs::_internal_add_extra_txos() {
  return extra_txos_.Add();
}
inline ::pb::Output* Outputs::add_extra_txos() {
  // @@protoc_insertion_point(field_add:pb.Outputs.extra_txos)
  return _internal_add_extra_txos();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Output >&
Outputs::extra_txos() const {
  // @@protoc_insertion_point(field_list:pb.Outputs.extra_txos)
  return extra_txos_;
}

// uint32 total = 3;
inline void Outputs::clear_total() {
  total_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Outputs::_internal_total() const {
  return total_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Outputs::total() const {
  // @@protoc_insertion_point(field_get:pb.Outputs.total)
  return _internal_total();
}
inline void Outputs::_internal_set_total(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  total_ = value;
}
inline void Outputs::set_total(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_total(value);
  // @@protoc_insertion_point(field_set:pb.Outputs.total)
}

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

// repeated .pb.Blocked blocked = 5;
inline int Outputs::_internal_blocked_size() const {
  return blocked_.size();
}
inline int Outputs::blocked_size() const {
  return _internal_blocked_size();
}
inline void Outputs::clear_blocked() {
  blocked_.Clear();
}
inline ::pb::Blocked* Outputs::mutable_blocked(int index) {
  // @@protoc_insertion_point(field_mutable:pb.Outputs.blocked)
  return blocked_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Blocked >*
Outputs::mutable_blocked() {
  // @@protoc_insertion_point(field_mutable_list:pb.Outputs.blocked)
  return &blocked_;
}
inline const ::pb::Blocked& Outputs::_internal_blocked(int index) const {
  return blocked_.Get(index);
}
inline const ::pb::Blocked& Outputs::blocked(int index) const {
  // @@protoc_insertion_point(field_get:pb.Outputs.blocked)
  return _internal_blocked(index);
}
inline ::pb::Blocked* Outputs::_internal_add_blocked() {
  return blocked_.Add();
}
inline ::pb::Blocked* Outputs::add_blocked() {
  // @@protoc_insertion_point(field_add:pb.Outputs.blocked)
  return _internal_add_blocked();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::pb::Blocked >&
Outputs::blocked() const {
  // @@protoc_insertion_point(field_list:pb.Outputs.blocked)
  return blocked_;
}

// uint32 blocked_total = 6;
inline void Outputs::clear_blocked_total() {
  blocked_total_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Outputs::_internal_blocked_total() const {
  return blocked_total_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Outputs::blocked_total() const {
  // @@protoc_insertion_point(field_get:pb.Outputs.blocked_total)
  return _internal_blocked_total();
}
inline void Outputs::_internal_set_blocked_total(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  blocked_total_ = value;
}
inline void Outputs::set_blocked_total(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_blocked_total(value);
  // @@protoc_insertion_point(field_set:pb.Outputs.blocked_total)
}

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

// Output

// bytes tx_hash = 1;
inline void Output::clear_tx_hash() {
  tx_hash_.ClearToEmpty();
}
inline const std::string& Output::tx_hash() const {
  // @@protoc_insertion_point(field_get:pb.Output.tx_hash)
  return _internal_tx_hash();
}
inline void Output::set_tx_hash(const std::string& value) {
  _internal_set_tx_hash(value);
  // @@protoc_insertion_point(field_set:pb.Output.tx_hash)
}
inline std::string* Output::mutable_tx_hash() {
  // @@protoc_insertion_point(field_mutable:pb.Output.tx_hash)
  return _internal_mutable_tx_hash();
}
inline const std::string& Output::_internal_tx_hash() const {
  return tx_hash_.Get();
}
inline void Output::_internal_set_tx_hash(const std::string& value) {
  
  tx_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Output::set_tx_hash(std::string&& value) {
  
  tx_hash_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.Output.tx_hash)
}
inline void Output::set_tx_hash(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  tx_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:pb.Output.tx_hash)
}
inline void Output::set_tx_hash(const void* value,
    size_t size) {
  
  tx_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:pb.Output.tx_hash)
}
inline std::string* Output::_internal_mutable_tx_hash() {
  
  return tx_hash_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Output::release_tx_hash() {
  // @@protoc_insertion_point(field_release:pb.Output.tx_hash)
  return tx_hash_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Output::set_allocated_tx_hash(std::string* tx_hash) {
  if (tx_hash != nullptr) {
    
  } else {
    
  }
  tx_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tx_hash,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:pb.Output.tx_hash)
}

// uint32 nout = 2;
inline void Output::clear_nout() {
  nout_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Output::_internal_nout() const {
  return nout_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Output::nout() const {
  // @@protoc_insertion_point(field_get:pb.Output.nout)
  return _internal_nout();
}
inline void Output::_internal_set_nout(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  nout_ = value;
}
inline void Output::set_nout(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_nout(value);
  // @@protoc_insertion_point(field_set:pb.Output.nout)
}

// uint32 height = 3;
inline void Output::clear_height() {
  height_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Output::_internal_height() const {
  return height_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Output::height() const {
  // @@protoc_insertion_point(field_get:pb.Output.height)
  return _internal_height();
}
inline void Output::_internal_set_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  height_ = value;
}
inline void Output::set_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_height(value);
  // @@protoc_insertion_point(field_set:pb.Output.height)
}

// .pb.ClaimMeta claim = 7;
inline bool Output::_internal_has_claim() const {
  return meta_case() == kClaim;
}
inline bool Output::has_claim() const {
  return _internal_has_claim();
}
inline void Output::set_has_claim() {
  _oneof_case_[0] = kClaim;
}
inline void Output::clear_claim() {
  if (_internal_has_claim()) {
    if (GetArena() == nullptr) {
      delete meta_.claim_;
    }
    clear_has_meta();
  }
}
inline ::pb::ClaimMeta* Output::release_claim() {
  // @@protoc_insertion_point(field_release:pb.Output.claim)
  if (_internal_has_claim()) {
    clear_has_meta();
      ::pb::ClaimMeta* temp = meta_.claim_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    meta_.claim_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pb::ClaimMeta& Output::_internal_claim() const {
  return _internal_has_claim()
      ? *meta_.claim_
      : reinterpret_cast< ::pb::ClaimMeta&>(::pb::_ClaimMeta_default_instance_);
}
inline const ::pb::ClaimMeta& Output::claim() const {
  // @@protoc_insertion_point(field_get:pb.Output.claim)
  return _internal_claim();
}
inline ::pb::ClaimMeta* Output::unsafe_arena_release_claim() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pb.Output.claim)
  if (_internal_has_claim()) {
    clear_has_meta();
    ::pb::ClaimMeta* temp = meta_.claim_;
    meta_.claim_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Output::unsafe_arena_set_allocated_claim(::pb::ClaimMeta* claim) {
  clear_meta();
  if (claim) {
    set_has_claim();
    meta_.claim_ = claim;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.Output.claim)
}
inline ::pb::ClaimMeta* Output::_internal_mutable_claim() {
  if (!_internal_has_claim()) {
    clear_meta();
    set_has_claim();
    meta_.claim_ = CreateMaybeMessage< ::pb::ClaimMeta >(GetArena());
  }
  return meta_.claim_;
}
inline ::pb::ClaimMeta* Output::mutable_claim() {
  // @@protoc_insertion_point(field_mutable:pb.Output.claim)
  return _internal_mutable_claim();
}

// .pb.Error error = 15;
inline bool Output::_internal_has_error() const {
  return meta_case() == kError;
}
inline bool Output::has_error() const {
  return _internal_has_error();
}
inline void Output::set_has_error() {
  _oneof_case_[0] = kError;
}
inline void Output::clear_error() {
  if (_internal_has_error()) {
    if (GetArena() == nullptr) {
      delete meta_.error_;
    }
    clear_has_meta();
  }
}
inline ::pb::Error* Output::release_error() {
  // @@protoc_insertion_point(field_release:pb.Output.error)
  if (_internal_has_error()) {
    clear_has_meta();
      ::pb::Error* temp = meta_.error_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    meta_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::pb::Error& Output::_internal_error() const {
  return _internal_has_error()
      ? *meta_.error_
      : reinterpret_cast< ::pb::Error&>(::pb::_Error_default_instance_);
}
inline const ::pb::Error& Output::error() const {
  // @@protoc_insertion_point(field_get:pb.Output.error)
  return _internal_error();
}
inline ::pb::Error* Output::unsafe_arena_release_error() {
  // @@protoc_insertion_point(field_unsafe_arena_release:pb.Output.error)
  if (_internal_has_error()) {
    clear_has_meta();
    ::pb::Error* temp = meta_.error_;
    meta_.error_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Output::unsafe_arena_set_allocated_error(::pb::Error* error) {
  clear_meta();
  if (error) {
    set_has_error();
    meta_.error_ = error;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.Output.error)
}
inline ::pb::Error* Output::_internal_mutable_error() {
  if (!_internal_has_error()) {
    clear_meta();
    set_has_error();
    meta_.error_ = CreateMaybeMessage< ::pb::Error >(GetArena());
  }
  return meta_.error_;
}
inline ::pb::Error* Output::mutable_error() {
  // @@protoc_insertion_point(field_mutable:pb.Output.error)
  return _internal_mutable_error();
}

inline bool Output::has_meta() const {
  return meta_case() != META_NOT_SET;
}
inline void Output::clear_has_meta() {
  _oneof_case_[0] = META_NOT_SET;
}
inline Output::MetaCase Output::meta_case() const {
  return Output::MetaCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// ClaimMeta

// .pb.Output channel = 1;
inline bool ClaimMeta::_internal_has_channel() const {
  return this != internal_default_instance() && channel_ != nullptr;
}
inline bool ClaimMeta::has_channel() const {
  return _internal_has_channel();
}
inline void ClaimMeta::clear_channel() {
  if (GetArena() == nullptr && channel_ != nullptr) {
    delete channel_;
  }
  channel_ = nullptr;
}
inline const ::pb::Output& ClaimMeta::_internal_channel() const {
  const ::pb::Output* p = channel_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::Output&>(
      ::pb::_Output_default_instance_);
}
inline const ::pb::Output& ClaimMeta::channel() const {
  // @@protoc_insertion_point(field_get:pb.ClaimMeta.channel)
  return _internal_channel();
}
inline void ClaimMeta::unsafe_arena_set_allocated_channel(
    ::pb::Output* channel) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(channel_);
  }
  channel_ = channel;
  if (channel) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.ClaimMeta.channel)
}
inline ::pb::Output* ClaimMeta::release_channel() {
  
  ::pb::Output* temp = channel_;
  channel_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::Output* ClaimMeta::unsafe_arena_release_channel() {
  // @@protoc_insertion_point(field_release:pb.ClaimMeta.channel)
  
  ::pb::Output* temp = channel_;
  channel_ = nullptr;
  return temp;
}
inline ::pb::Output* ClaimMeta::_internal_mutable_channel() {
  
  if (channel_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::Output>(GetArena());
    channel_ = p;
  }
  return channel_;
}
inline ::pb::Output* ClaimMeta::mutable_channel() {
  // @@protoc_insertion_point(field_mutable:pb.ClaimMeta.channel)
  return _internal_mutable_channel();
}
inline void ClaimMeta::set_allocated_channel(::pb::Output* channel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete channel_;
  }
  if (channel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(channel);
    if (message_arena != submessage_arena) {
      channel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, channel, submessage_arena);
    }
    
  } else {
    
  }
  channel_ = channel;
  // @@protoc_insertion_point(field_set_allocated:pb.ClaimMeta.channel)
}

// .pb.Output repost = 2;
inline bool ClaimMeta::_internal_has_repost() const {
  return this != internal_default_instance() && repost_ != nullptr;
}
inline bool ClaimMeta::has_repost() const {
  return _internal_has_repost();
}
inline void ClaimMeta::clear_repost() {
  if (GetArena() == nullptr && repost_ != nullptr) {
    delete repost_;
  }
  repost_ = nullptr;
}
inline const ::pb::Output& ClaimMeta::_internal_repost() const {
  const ::pb::Output* p = repost_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::Output&>(
      ::pb::_Output_default_instance_);
}
inline const ::pb::Output& ClaimMeta::repost() const {
  // @@protoc_insertion_point(field_get:pb.ClaimMeta.repost)
  return _internal_repost();
}
inline void ClaimMeta::unsafe_arena_set_allocated_repost(
    ::pb::Output* repost) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(repost_);
  }
  repost_ = repost;
  if (repost) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.ClaimMeta.repost)
}
inline ::pb::Output* ClaimMeta::release_repost() {
  
  ::pb::Output* temp = repost_;
  repost_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::Output* ClaimMeta::unsafe_arena_release_repost() {
  // @@protoc_insertion_point(field_release:pb.ClaimMeta.repost)
  
  ::pb::Output* temp = repost_;
  repost_ = nullptr;
  return temp;
}
inline ::pb::Output* ClaimMeta::_internal_mutable_repost() {
  
  if (repost_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::Output>(GetArena());
    repost_ = p;
  }
  return repost_;
}
inline ::pb::Output* ClaimMeta::mutable_repost() {
  // @@protoc_insertion_point(field_mutable:pb.ClaimMeta.repost)
  return _internal_mutable_repost();
}
inline void ClaimMeta::set_allocated_repost(::pb::Output* repost) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete repost_;
  }
  if (repost) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(repost);
    if (message_arena != submessage_arena) {
      repost = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, repost, submessage_arena);
    }
    
  } else {
    
  }
  repost_ = repost;
  // @@protoc_insertion_point(field_set_allocated:pb.ClaimMeta.repost)
}

// string short_url = 3;
inline void ClaimMeta::clear_short_url() {
  short_url_.ClearToEmpty();
}
inline const std::string& ClaimMeta::short_url() const {
  // @@protoc_insertion_point(field_get:pb.ClaimMeta.short_url)
  return _internal_short_url();
}
inline void ClaimMeta::set_short_url(const std::string& value) {
  _internal_set_short_url(value);
  // @@protoc_insertion_point(field_set:pb.ClaimMeta.short_url)
}
inline std::string* ClaimMeta::mutable_short_url() {
  // @@protoc_insertion_point(field_mutable:pb.ClaimMeta.short_url)
  return _internal_mutable_short_url();
}
inline const std::string& ClaimMeta::_internal_short_url() const {
  return short_url_.Get();
}
inline void ClaimMeta::_internal_set_short_url(const std::string& value) {
  
  short_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ClaimMeta::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.ClaimMeta.short_url)
}
inline void ClaimMeta::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.ClaimMeta.short_url)
}
inline void ClaimMeta::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.ClaimMeta.short_url)
}
inline std::string* ClaimMeta::_internal_mutable_short_url() {
  
  return short_url_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ClaimMeta::release_short_url() {
  // @@protoc_insertion_point(field_release:pb.ClaimMeta.short_url)
  return short_url_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ClaimMeta::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.ClaimMeta.short_url)
}

// string canonical_url = 4;
inline void ClaimMeta::clear_canonical_url() {
  canonical_url_.ClearToEmpty();
}
inline const std::string& ClaimMeta::canonical_url() const {
  // @@protoc_insertion_point(field_get:pb.ClaimMeta.canonical_url)
  return _internal_canonical_url();
}
inline void ClaimMeta::set_canonical_url(const std::string& value) {
  _internal_set_canonical_url(value);
  // @@protoc_insertion_point(field_set:pb.ClaimMeta.canonical_url)
}
inline std::string* ClaimMeta::mutable_canonical_url() {
  // @@protoc_insertion_point(field_mutable:pb.ClaimMeta.canonical_url)
  return _internal_mutable_canonical_url();
}
inline const std::string& ClaimMeta::_internal_canonical_url() const {
  return canonical_url_.Get();
}
inline void ClaimMeta::_internal_set_canonical_url(const std::string& value) {
  
  canonical_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ClaimMeta::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.ClaimMeta.canonical_url)
}
inline void ClaimMeta::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.ClaimMeta.canonical_url)
}
inline void ClaimMeta::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.ClaimMeta.canonical_url)
}
inline std::string* ClaimMeta::_internal_mutable_canonical_url() {
  
  return canonical_url_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ClaimMeta::release_canonical_url() {
  // @@protoc_insertion_point(field_release:pb.ClaimMeta.canonical_url)
  return canonical_url_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ClaimMeta::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.ClaimMeta.canonical_url)
}

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

// uint32 take_over_height = 6;
inline void ClaimMeta::clear_take_over_height() {
  take_over_height_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::_internal_take_over_height() const {
  return take_over_height_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::take_over_height() const {
  // @@protoc_insertion_point(field_get:pb.ClaimMeta.take_over_height)
  return _internal_take_over_height();
}
inline void ClaimMeta::_internal_set_take_over_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  take_over_height_ = value;
}
inline void ClaimMeta::set_take_over_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_take_over_height(value);
  // @@protoc_insertion_point(field_set:pb.ClaimMeta.take_over_height)
}

// uint32 creation_height = 7;
inline void ClaimMeta::clear_creation_height() {
  creation_height_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::_internal_creation_height() const {
  return creation_height_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::creation_height() const {
  // @@protoc_insertion_point(field_get:pb.ClaimMeta.creation_height)
  return _internal_creation_height();
}
inline void ClaimMeta::_internal_set_creation_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  creation_height_ = value;
}
inline void ClaimMeta::set_creation_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_creation_height(value);
  // @@protoc_insertion_point(field_set:pb.ClaimMeta.creation_height)
}

// uint32 activation_height = 8;
inline void ClaimMeta::clear_activation_height() {
  activation_height_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::_internal_activation_height() const {
  return activation_height_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::activation_height() const {
  // @@protoc_insertion_point(field_get:pb.ClaimMeta.activation_height)
  return _internal_activation_height();
}
inline void ClaimMeta::_internal_set_activation_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  activation_height_ = value;
}
inline void ClaimMeta::set_activation_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_activation_height(value);
  // @@protoc_insertion_point(field_set:pb.ClaimMeta.activation_height)
}

// uint32 expiration_height = 9;
inline void ClaimMeta::clear_expiration_height() {
  expiration_height_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::_internal_expiration_height() const {
  return expiration_height_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::expiration_height() const {
  // @@protoc_insertion_point(field_get:pb.ClaimMeta.expiration_height)
  return _internal_expiration_height();
}
inline void ClaimMeta::_internal_set_expiration_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  expiration_height_ = value;
}
inline void ClaimMeta::set_expiration_height(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_expiration_height(value);
  // @@protoc_insertion_point(field_set:pb.ClaimMeta.expiration_height)
}

// uint32 claims_in_channel = 10;
inline void ClaimMeta::clear_claims_in_channel() {
  claims_in_channel_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::_internal_claims_in_channel() const {
  return claims_in_channel_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::claims_in_channel() const {
  // @@protoc_insertion_point(field_get:pb.ClaimMeta.claims_in_channel)
  return _internal_claims_in_channel();
}
inline void ClaimMeta::_internal_set_claims_in_channel(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  claims_in_channel_ = value;
}
inline void ClaimMeta::set_claims_in_channel(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_claims_in_channel(value);
  // @@protoc_insertion_point(field_set:pb.ClaimMeta.claims_in_channel)
}

// uint32 reposted = 11;
inline void ClaimMeta::clear_reposted() {
  reposted_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::_internal_reposted() const {
  return reposted_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 ClaimMeta::reposted() const {
  // @@protoc_insertion_point(field_get:pb.ClaimMeta.reposted)
  return _internal_reposted();
}
inline void ClaimMeta::_internal_set_reposted(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  reposted_ = value;
}
inline void ClaimMeta::set_reposted(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_reposted(value);
  // @@protoc_insertion_point(field_set:pb.ClaimMeta.reposted)
}

// uint64 effective_amount = 20;
inline void ClaimMeta::clear_effective_amount() {
  effective_amount_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 ClaimMeta::_internal_effective_amount() const {
  return effective_amount_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 ClaimMeta::effective_amount() const {
  // @@protoc_insertion_point(field_get:pb.ClaimMeta.effective_amount)
  return _internal_effective_amount();
}
inline void ClaimMeta::_internal_set_effective_amount(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  effective_amount_ = value;
}
inline void ClaimMeta::set_effective_amount(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_set_effective_amount(value);
  // @@protoc_insertion_point(field_set:pb.ClaimMeta.effective_amount)
}

// uint64 support_amount = 21;
inline void ClaimMeta::clear_support_amount() {
  support_amount_ = PROTOBUF_ULONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 ClaimMeta::_internal_support_amount() const {
  return support_amount_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 ClaimMeta::support_amount() const {
  // @@protoc_insertion_point(field_get:pb.ClaimMeta.support_amount)
  return _internal_support_amount();
}
inline void ClaimMeta::_internal_set_support_amount(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  support_amount_ = value;
}
inline void ClaimMeta::set_support_amount(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_set_support_amount(value);
  // @@protoc_insertion_point(field_set:pb.ClaimMeta.support_amount)
}

// double trending_score = 22;
inline void ClaimMeta::clear_trending_score() {
  trending_score_ = 0;
}
inline double ClaimMeta::_internal_trending_score() const {
  return trending_score_;
}
inline double ClaimMeta::trending_score() const {
  // @@protoc_insertion_point(field_get:pb.ClaimMeta.trending_score)
  return _internal_trending_score();
}
inline void ClaimMeta::_internal_set_trending_score(double value) {
  
  trending_score_ = value;
}
inline void ClaimMeta::set_trending_score(double value) {
  _internal_set_trending_score(value);
  // @@protoc_insertion_point(field_set:pb.ClaimMeta.trending_score)
}

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

// Error

// .pb.Error.Code code = 1;
inline void Error::clear_code() {
  code_ = 0;
}
inline ::pb::Error_Code Error::_internal_code() const {
  return static_cast< ::pb::Error_Code >(code_);
}
inline ::pb::Error_Code Error::code() const {
  // @@protoc_insertion_point(field_get:pb.Error.code)
  return _internal_code();
}
inline void Error::_internal_set_code(::pb::Error_Code value) {
  
  code_ = value;
}
inline void Error::set_code(::pb::Error_Code value) {
  _internal_set_code(value);
  // @@protoc_insertion_point(field_set:pb.Error.code)
}

// string text = 2;
inline void Error::clear_text() {
  text_.ClearToEmpty();
}
inline const std::string& Error::text() const {
  // @@protoc_insertion_point(field_get:pb.Error.text)
  return _internal_text();
}
inline void Error::set_text(const std::string& value) {
  _internal_set_text(value);
  // @@protoc_insertion_point(field_set:pb.Error.text)
}
inline std::string* Error::mutable_text() {
  // @@protoc_insertion_point(field_mutable:pb.Error.text)
  return _internal_mutable_text();
}
inline const std::string& Error::_internal_text() const {
  return text_.Get();
}
inline void Error::_internal_set_text(const std::string& value) {
  
  text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Error::set_text(std::string&& value) {
  
  text_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:pb.Error.text)
}
inline void Error::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.Error.text)
}
inline void Error::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.Error.text)
}
inline std::string* Error::_internal_mutable_text() {
  
  return text_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Error::release_text() {
  // @@protoc_insertion_point(field_release:pb.Error.text)
  return text_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Error::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.Error.text)
}

// .pb.Blocked blocked = 3;
inline bool Error::_internal_has_blocked() const {
  return this != internal_default_instance() && blocked_ != nullptr;
}
inline bool Error::has_blocked() const {
  return _internal_has_blocked();
}
inline void Error::clear_blocked() {
  if (GetArena() == nullptr && blocked_ != nullptr) {
    delete blocked_;
  }
  blocked_ = nullptr;
}
inline const ::pb::Blocked& Error::_internal_blocked() const {
  const ::pb::Blocked* p = blocked_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::Blocked&>(
      ::pb::_Blocked_default_instance_);
}
inline const ::pb::Blocked& Error::blocked() const {
  // @@protoc_insertion_point(field_get:pb.Error.blocked)
  return _internal_blocked();
}
inline void Error::unsafe_arena_set_allocated_blocked(
    ::pb::Blocked* blocked) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(blocked_);
  }
  blocked_ = blocked;
  if (blocked) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.Error.blocked)
}
inline ::pb::Blocked* Error::release_blocked() {
  
  ::pb::Blocked* temp = blocked_;
  blocked_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::Blocked* Error::unsafe_arena_release_blocked() {
  // @@protoc_insertion_point(field_release:pb.Error.blocked)
  
  ::pb::Blocked* temp = blocked_;
  blocked_ = nullptr;
  return temp;
}
inline ::pb::Blocked* Error::_internal_mutable_blocked() {
  
  if (blocked_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::Blocked>(GetArena());
    blocked_ = p;
  }
  return blocked_;
}
inline ::pb::Blocked* Error::mutable_blocked() {
  // @@protoc_insertion_point(field_mutable:pb.Error.blocked)
  return _internal_mutable_blocked();
}
inline void Error::set_allocated_blocked(::pb::Blocked* blocked) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete blocked_;
  }
  if (blocked) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(blocked);
    if (message_arena != submessage_arena) {
      blocked = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, blocked, submessage_arena);
    }
    
  } else {
    
  }
  blocked_ = blocked;
  // @@protoc_insertion_point(field_set_allocated:pb.Error.blocked)
}

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

// Blocked

// uint32 count = 1;
inline void Blocked::clear_count() {
  count_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Blocked::_internal_count() const {
  return count_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 Blocked::count() const {
  // @@protoc_insertion_point(field_get:pb.Blocked.count)
  return _internal_count();
}
inline void Blocked::_internal_set_count(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  count_ = value;
}
inline void Blocked::set_count(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_count(value);
  // @@protoc_insertion_point(field_set:pb.Blocked.count)
}

// .pb.Output channel = 2;
inline bool Blocked::_internal_has_channel() const {
  return this != internal_default_instance() && channel_ != nullptr;
}
inline bool Blocked::has_channel() const {
  return _internal_has_channel();
}
inline void Blocked::clear_channel() {
  if (GetArena() == nullptr && channel_ != nullptr) {
    delete channel_;
  }
  channel_ = nullptr;
}
inline const ::pb::Output& Blocked::_internal_channel() const {
  const ::pb::Output* p = channel_;
  return p != nullptr ? *p : reinterpret_cast<const ::pb::Output&>(
      ::pb::_Output_default_instance_);
}
inline const ::pb::Output& Blocked::channel() const {
  // @@protoc_insertion_point(field_get:pb.Blocked.channel)
  return _internal_channel();
}
inline void Blocked::unsafe_arena_set_allocated_channel(
    ::pb::Output* channel) {
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(channel_);
  }
  channel_ = channel;
  if (channel) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:pb.Blocked.channel)
}
inline ::pb::Output* Blocked::release_channel() {
  
  ::pb::Output* temp = channel_;
  channel_ = nullptr;
  if (GetArena() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
  return temp;
}
inline ::pb::Output* Blocked::unsafe_arena_release_channel() {
  // @@protoc_insertion_point(field_release:pb.Blocked.channel)
  
  ::pb::Output* temp = channel_;
  channel_ = nullptr;
  return temp;
}
inline ::pb::Output* Blocked::_internal_mutable_channel() {
  
  if (channel_ == nullptr) {
    auto* p = CreateMaybeMessage<::pb::Output>(GetArena());
    channel_ = p;
  }
  return channel_;
}
inline ::pb::Output* Blocked::mutable_channel() {
  // @@protoc_insertion_point(field_mutable:pb.Blocked.channel)
  return _internal_mutable_channel();
}
inline void Blocked::set_allocated_channel(::pb::Output* channel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
  if (message_arena == nullptr) {
    delete channel_;
  }
  if (channel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(channel);
    if (message_arena != submessage_arena) {
      channel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, channel, submessage_arena);
    }
    
  } else {
    
  }
  channel_ = channel;
  // @@protoc_insertion_point(field_set_allocated:pb.Blocked.channel)
}

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace pb

PROTOBUF_NAMESPACE_OPEN

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

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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