text: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  // source: common/common.proto
  
  #ifndef GOOGLE_PROTOBUF_INCLUDED_common_2fcommon_2eproto
  #define GOOGLE_PROTOBUF_INCLUDED_common_2fcommon_2eproto
  
  #include <limits>
  #include <string>
  
  #include <google/protobuf/port_def.inc>
  #if PROTOBUF_VERSION < 3012000
  #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 3012003 < 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/inlined_string_field.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 <google/protobuf/timestamp.pb.h>
  // @@protoc_insertion_point(includes)
  #include <google/protobuf/port_def.inc>
  #define PROTOBUF_INTERNAL_EXPORT_common_2fcommon_2eproto
  PROTOBUF_NAMESPACE_OPEN
  namespace internal {
  class AnyMetadata;
  }  // namespace internal
  PROTOBUF_NAMESPACE_CLOSE
  
  // Internal implementation detail -- do not use these members.
  struct TableStruct_common_2fcommon_2eproto {
    static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
      PROTOBUF_SECTION_VARIABLE(protodesc_cold);
    static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
      PROTOBUF_SECTION_VARIABLE(protodesc_cold);
    static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[13]
      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_common_2fcommon_2eproto;
  namespace common {
  class Block;
  class BlockDefaultTypeInternal;
  extern BlockDefaultTypeInternal _Block_default_instance_;
  class BlockData;
  class BlockDataDefaultTypeInternal;
  extern BlockDataDefaultTypeInternal _BlockData_default_instance_;
  class BlockHeader;
  class BlockHeaderDefaultTypeInternal;
  extern BlockHeaderDefaultTypeInternal _BlockHeader_default_instance_;
  class BlockMetadata;
  class BlockMetadataDefaultTypeInternal;
  extern BlockMetadataDefaultTypeInternal _BlockMetadata_default_instance_;
  class ChannelHeader;
  class ChannelHeaderDefaultTypeInternal;
  extern ChannelHeaderDefaultTypeInternal _ChannelHeader_default_instance_;
  class Envelope;
  class EnvelopeDefaultTypeInternal;
  extern EnvelopeDefaultTypeInternal _Envelope_default_instance_;
  class Header;
  class HeaderDefaultTypeInternal;
  extern HeaderDefaultTypeInternal _Header_default_instance_;
  class LastConfig;
  class LastConfigDefaultTypeInternal;
  extern LastConfigDefaultTypeInternal _LastConfig_default_instance_;
  class Metadata;
  class MetadataDefaultTypeInternal;
  extern MetadataDefaultTypeInternal _Metadata_default_instance_;
  class MetadataSignature;
  class MetadataSignatureDefaultTypeInternal;
  extern MetadataSignatureDefaultTypeInternal _MetadataSignature_default_instance_;
  class OrdererBlockMetadata;
  class OrdererBlockMetadataDefaultTypeInternal;
  extern OrdererBlockMetadataDefaultTypeInternal _OrdererBlockMetadata_default_instance_;
  class Payload;
  class PayloadDefaultTypeInternal;
  extern PayloadDefaultTypeInternal _Payload_default_instance_;
  class SignatureHeader;
  class SignatureHeaderDefaultTypeInternal;
  extern SignatureHeaderDefaultTypeInternal _SignatureHeader_default_instance_;
  }  // namespace common
  PROTOBUF_NAMESPACE_OPEN
  template<> ::common::Block* Arena::CreateMaybeMessage<::common::Block>(Arena*);
  template<> ::common::BlockData* Arena::CreateMaybeMessage<::common::BlockData>(Arena*);
  template<> ::common::BlockHeader* Arena::CreateMaybeMessage<::common::BlockHeader>(Arena*);
  template<> ::common::BlockMetadata* Arena::CreateMaybeMessage<::common::BlockMetadata>(Arena*);
  template<> ::common::ChannelHeader* Arena::CreateMaybeMessage<::common::ChannelHeader>(Arena*);
  template<> ::common::Envelope* Arena::CreateMaybeMessage<::common::Envelope>(Arena*);
  template<> ::common::Header* Arena::CreateMaybeMessage<::common::Header>(Arena*);
  template<> ::common::LastConfig* Arena::CreateMaybeMessage<::common::LastConfig>(Arena*);
  template<> ::common::Metadata* Arena::CreateMaybeMessage<::common::Metadata>(Arena*);
  template<> ::common::MetadataSignature* Arena::CreateMaybeMessage<::common::MetadataSignature>(Arena*);
  template<> ::common::OrdererBlockMetadata* Arena::CreateMaybeMessage<::common::OrdererBlockMetadata>(Arena*);
  template<> ::common::Payload* Arena::CreateMaybeMessage<::common::Payload>(Arena*);
  template<> ::common::SignatureHeader* Arena::CreateMaybeMessage<::common::SignatureHeader>(Arena*);
  PROTOBUF_NAMESPACE_CLOSE
  namespace common {
  
  enum Status : int {
    UNKNOWN = 0,
    SUCCESS = 200,
    BAD_REQUEST = 400,
    FORBIDDEN = 403,
    NOT_FOUND = 404,
    REQUEST_ENTITY_TOO_LARGE = 413,
    INTERNAL_SERVER_ERROR = 500,
    NOT_IMPLEMENTED = 501,
    SERVICE_UNAVAILABLE = 503,
    Status_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
    Status_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
  };
  bool Status_IsValid(int value);
  constexpr Status Status_MIN = UNKNOWN;
  constexpr Status Status_MAX = SERVICE_UNAVAILABLE;
  constexpr int Status_ARRAYSIZE = Status_MAX + 1;
  
  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Status_descriptor();
  template<typename T>
  inline const std::string& Status_Name(T enum_t_value) {
    static_assert(::std::is_same<T, Status>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function Status_Name.");
    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
      Status_descriptor(), enum_t_value);
  }
  inline bool Status_Parse(
      const std::string& name, Status* value) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Status>(
      Status_descriptor(), name, value);
  }
  enum HeaderType : int {
    MESSAGE = 0,
    CONFIG = 1,
    CONFIG_UPDATE = 2,
    ENDORSER_TRANSACTION = 3,
    ORDERER_TRANSACTION = 4,
    DELIVER_SEEK_INFO = 5,
    CHAINCODE_PACKAGE = 6,
    PEER_ADMIN_OPERATION = 8,
    TOKEN_TRANSACTION = 9,
    HeaderType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
    HeaderType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
  };
  bool HeaderType_IsValid(int value);
  constexpr HeaderType HeaderType_MIN = MESSAGE;
  constexpr HeaderType HeaderType_MAX = TOKEN_TRANSACTION;
  constexpr int HeaderType_ARRAYSIZE = HeaderType_MAX + 1;
  
  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HeaderType_descriptor();
  template<typename T>
  inline const std::string& HeaderType_Name(T enum_t_value) {
    static_assert(::std::is_same<T, HeaderType>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function HeaderType_Name.");
    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
      HeaderType_descriptor(), enum_t_value);
  }
  inline bool HeaderType_Parse(
      const std::string& name, HeaderType* value) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HeaderType>(
      HeaderType_descriptor(), name, value);
  }
  enum BlockMetadataIndex : int {
    SIGNATURES = 0,
    LAST_CONFIG = 1,
    TRANSACTIONS_FILTER = 2,
    ORDERER = 3,
    COMMIT_HASH = 4,
    BlockMetadataIndex_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
    BlockMetadataIndex_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
  };
  bool BlockMetadataIndex_IsValid(int value);
  constexpr BlockMetadataIndex BlockMetadataIndex_MIN = SIGNATURES;
  constexpr BlockMetadataIndex BlockMetadataIndex_MAX = COMMIT_HASH;
  constexpr int BlockMetadataIndex_ARRAYSIZE = BlockMetadataIndex_MAX + 1;
  
  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* BlockMetadataIndex_descriptor();
  template<typename T>
  inline const std::string& BlockMetadataIndex_Name(T enum_t_value) {
    static_assert(::std::is_same<T, BlockMetadataIndex>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function BlockMetadataIndex_Name.");
    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
      BlockMetadataIndex_descriptor(), enum_t_value);
  }
  inline bool BlockMetadataIndex_Parse(
      const std::string& name, BlockMetadataIndex* value) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<BlockMetadataIndex>(
      BlockMetadataIndex_descriptor(), name, value);
  }
  // ===================================================================
  
  class LastConfig PROTOBUF_FINAL :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:common.LastConfig) */ {
   public:
    inline LastConfig() : LastConfig(nullptr) {};
    virtual ~LastConfig();
  
    LastConfig(const LastConfig& from);
    LastConfig(LastConfig&& from) noexcept
      : LastConfig() {
      *this = ::std::move(from);
    }
  
    inline LastConfig& operator=(const LastConfig& from) {
      CopyFrom(from);
      return *this;
    }
    inline LastConfig& operator=(LastConfig&& 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 LastConfig& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const LastConfig* internal_default_instance() {
      return reinterpret_cast<const LastConfig*>(
                 &_LastConfig_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      0;
  
    friend void swap(LastConfig& a, LastConfig& b) {
      a.Swap(&b);
    }
    inline void Swap(LastConfig* other) {
      if (other == this) return;
      if (GetArena() == other->GetArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(LastConfig* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetArena() == other->GetArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline LastConfig* New() const final {
      return CreateMaybeMessage<LastConfig>(nullptr);
    }
  
    LastConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<LastConfig>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const LastConfig& from);
    void MergeFrom(const LastConfig& 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(LastConfig* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "common.LastConfig";
    }
    protected:
    explicit LastConfig(::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() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2fcommon_2eproto);
      return ::descriptor_table_common_2fcommon_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kIndexFieldNumber = 1,
    };
    // uint64 index = 1;
    void clear_index();
    ::PROTOBUF_NAMESPACE_ID::uint64 index() const;
    void set_index(::PROTOBUF_NAMESPACE_ID::uint64 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::uint64 _internal_index() const;
    void _internal_set_index(::PROTOBUF_NAMESPACE_ID::uint64 value);
    public:
  
    // @@protoc_insertion_point(class_scope:common.LastConfig)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::PROTOBUF_NAMESPACE_ID::uint64 index_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2fcommon_2eproto;
  };
  // -------------------------------------------------------------------
  
  class Metadata PROTOBUF_FINAL :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:common.Metadata) */ {
   public:
    inline Metadata() : Metadata(nullptr) {};
    virtual ~Metadata();
  
    Metadata(const Metadata& from);
    Metadata(Metadata&& from) noexcept
      : Metadata() {
      *this = ::std::move(from);
    }
  
    inline Metadata& operator=(const Metadata& from) {
      CopyFrom(from);
      return *this;
    }
    inline Metadata& operator=(Metadata&& 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 Metadata& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const Metadata* internal_default_instance() {
      return reinterpret_cast<const Metadata*>(
                 &_Metadata_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      1;
  
    friend void swap(Metadata& a, Metadata& b) {
      a.Swap(&b);
    }
    inline void Swap(Metadata* other) {
      if (other == this) return;
      if (GetArena() == other->GetArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(Metadata* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetArena() == other->GetArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline Metadata* New() const final {
      return CreateMaybeMessage<Metadata>(nullptr);
    }
  
    Metadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<Metadata>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const Metadata& from);
    void MergeFrom(const Metadata& 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(Metadata* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "common.Metadata";
    }
    protected:
    explicit Metadata(::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() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2fcommon_2eproto);
      return ::descriptor_table_common_2fcommon_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kSignaturesFieldNumber = 2,
      kValueFieldNumber = 1,
    };
    // repeated .common.MetadataSignature signatures = 2;
    int signatures_size() const;
    private:
    int _internal_signatures_size() const;
    public:
    void clear_signatures();
    ::common::MetadataSignature* mutable_signatures(int index);
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::common::MetadataSignature >*
        mutable_signatures();
    private:
    const ::common::MetadataSignature& _internal_signatures(int index) const;
    ::common::MetadataSignature* _internal_add_signatures();
    public:
    const ::common::MetadataSignature& signatures(int index) const;
    ::common::MetadataSignature* add_signatures();
    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::common::MetadataSignature >&
        signatures() const;
  
    // bytes value = 1;
    void clear_value();
    const std::string& value() const;
    void set_value(const std::string& value);
    void set_value(std::string&& value);
    void set_value(const char* value);
    void set_value(const void* value, size_t size);
    std::string* mutable_value();
    std::string* release_value();
    void set_allocated_value(std::string* value);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_value();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_set_allocated_value(
        std::string* value);
    private:
    const std::string& _internal_value() const;
    void _internal_set_value(const std::string& value);
    std::string* _internal_mutable_value();
    public:
  
    // @@protoc_insertion_point(class_scope:common.Metadata)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::common::MetadataSignature > signatures_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2fcommon_2eproto;
  };
  // -------------------------------------------------------------------
  
  class MetadataSignature PROTOBUF_FINAL :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:common.MetadataSignature) */ {
   public:
    inline MetadataSignature() : MetadataSignature(nullptr) {};
    virtual ~MetadataSignature();
  
    MetadataSignature(const MetadataSignature& from);
    MetadataSignature(MetadataSignature&& from) noexcept
      : MetadataSignature() {
      *this = ::std::move(from);
    }
  
    inline MetadataSignature& operator=(const MetadataSignature& from) {
      CopyFrom(from);
      return *this;
    }
    inline MetadataSignature& operator=(MetadataSignature&& 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 MetadataSignature& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const MetadataSignature* internal_default_instance() {
      return reinterpret_cast<const MetadataSignature*>(
                 &_MetadataSignature_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      2;
  
    friend void swap(MetadataSignature& a, MetadataSignature& b) {
      a.Swap(&b);
    }
    inline void Swap(MetadataSignature* other) {
      if (other == this) return;
      if (GetArena() == other->GetArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(MetadataSignature* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetArena() == other->GetArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline MetadataSignature* New() const final {
      return CreateMaybeMessage<MetadataSignature>(nullptr);
    }
  
    MetadataSignature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<MetadataSignature>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const MetadataSignature& from);
    void MergeFrom(const MetadataSignature& 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(MetadataSignature* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "common.MetadataSignature";
    }
    protected:
    explicit MetadataSignature(::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() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2fcommon_2eproto);
      return ::descriptor_table_common_2fcommon_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kSignatureHeaderFieldNumber = 1,
      kSignatureFieldNumber = 2,
    };
    // bytes signature_header = 1;
    void clear_signature_header();
    const std::string& signature_header() const;
    void set_signature_header(const std::string& value);
    void set_signature_header(std::string&& value);
    void set_signature_header(const char* value);
    void set_signature_header(const void* value, size_t size);
    std::string* mutable_signature_header();
    std::string* release_signature_header();
    void set_allocated_signature_header(std::string* signature_header);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_signature_header();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_set_allocated_signature_header(
        std::string* signature_header);
    private:
    const std::string& _internal_signature_header() const;
    void _internal_set_signature_header(const std::string& value);
    std::string* _internal_mutable_signature_header();
    public:
  
    // bytes signature = 2;
    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 void* value, size_t size);
    std::string* mutable_signature();
    std::string* release_signature();
    void set_allocated_signature(std::string* signature);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_signature();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_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:
  
    // @@protoc_insertion_point(class_scope:common.MetadataSignature)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_header_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2fcommon_2eproto;
  };
  // -------------------------------------------------------------------
  
  class Header PROTOBUF_FINAL :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:common.Header) */ {
   public:
    inline Header() : Header(nullptr) {};
    virtual ~Header();
  
    Header(const Header& from);
    Header(Header&& from) noexcept
      : Header() {
      *this = ::std::move(from);
    }
  
    inline Header& operator=(const Header& from) {
      CopyFrom(from);
      return *this;
    }
    inline Header& operator=(Header&& 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 Header& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const Header* internal_default_instance() {
      return reinterpret_cast<const Header*>(
                 &_Header_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      3;
  
    friend void swap(Header& a, Header& b) {
      a.Swap(&b);
    }
    inline void Swap(Header* other) {
      if (other == this) return;
      if (GetArena() == other->GetArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(Header* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetArena() == other->GetArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline Header* New() const final {
      return CreateMaybeMessage<Header>(nullptr);
    }
  
    Header* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<Header>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const Header& from);
    void MergeFrom(const Header& 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(Header* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "common.Header";
    }
    protected:
    explicit Header(::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() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2fcommon_2eproto);
      return ::descriptor_table_common_2fcommon_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kChannelHeaderFieldNumber = 1,
      kSignatureHeaderFieldNumber = 2,
    };
    // bytes channel_header = 1;
    void clear_channel_header();
    const std::string& channel_header() const;
    void set_channel_header(const std::string& value);
    void set_channel_header(std::string&& value);
    void set_channel_header(const char* value);
    void set_channel_header(const void* value, size_t size);
    std::string* mutable_channel_header();
    std::string* release_channel_header();
    void set_allocated_channel_header(std::string* channel_header);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_channel_header();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_set_allocated_channel_header(
        std::string* channel_header);
    private:
    const std::string& _internal_channel_header() const;
    void _internal_set_channel_header(const std::string& value);
    std::string* _internal_mutable_channel_header();
    public:
  
    // bytes signature_header = 2;
    void clear_signature_header();
    const std::string& signature_header() const;
    void set_signature_header(const std::string& value);
    void set_signature_header(std::string&& value);
    void set_signature_header(const char* value);
    void set_signature_header(const void* value, size_t size);
    std::string* mutable_signature_header();
    std::string* release_signature_header();
    void set_allocated_signature_header(std::string* signature_header);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_signature_header();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_set_allocated_signature_header(
        std::string* signature_header);
    private:
    const std::string& _internal_signature_header() const;
    void _internal_set_signature_header(const std::string& value);
    std::string* _internal_mutable_signature_header();
    public:
  
    // @@protoc_insertion_point(class_scope:common.Header)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr channel_header_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_header_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2fcommon_2eproto;
  };
  // -------------------------------------------------------------------
  
  class ChannelHeader PROTOBUF_FINAL :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:common.ChannelHeader) */ {
   public:
    inline ChannelHeader() : ChannelHeader(nullptr) {};
    virtual ~ChannelHeader();
  
    ChannelHeader(const ChannelHeader& from);
    ChannelHeader(ChannelHeader&& from) noexcept
      : ChannelHeader() {
      *this = ::std::move(from);
    }
  
    inline ChannelHeader& operator=(const ChannelHeader& from) {
      CopyFrom(from);
      return *this;
    }
    inline ChannelHeader& operator=(ChannelHeader&& 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 ChannelHeader& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const ChannelHeader* internal_default_instance() {
      return reinterpret_cast<const ChannelHeader*>(
                 &_ChannelHeader_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      4;
  
    friend void swap(ChannelHeader& a, ChannelHeader& b) {
      a.Swap(&b);
    }
    inline void Swap(ChannelHeader* other) {
      if (other == this) return;
      if (GetArena() == other->GetArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(ChannelHeader* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetArena() == other->GetArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline ChannelHeader* New() const final {
      return CreateMaybeMessage<ChannelHeader>(nullptr);
    }
  
    ChannelHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<ChannelHeader>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const ChannelHeader& from);
    void MergeFrom(const ChannelHeader& 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(ChannelHeader* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "common.ChannelHeader";
    }
    protected:
    explicit ChannelHeader(::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() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2fcommon_2eproto);
      return ::descriptor_table_common_2fcommon_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kChannelIdFieldNumber = 4,
      kTxIdFieldNumber = 5,
      kExtensionFieldNumber = 7,
      kTlsCertHashFieldNumber = 8,
      kTimestampFieldNumber = 3,
      kTypeFieldNumber = 1,
      kVersionFieldNumber = 2,
      kEpochFieldNumber = 6,
    };
    // string channel_id = 4;
    void clear_channel_id();
    const std::string& channel_id() const;
    void set_channel_id(const std::string& value);
    void set_channel_id(std::string&& value);
    void set_channel_id(const char* value);
    void set_channel_id(const char* value, size_t size);
    std::string* mutable_channel_id();
    std::string* release_channel_id();
    void set_allocated_channel_id(std::string* channel_id);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_channel_id();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_set_allocated_channel_id(
        std::string* channel_id);
    private:
    const std::string& _internal_channel_id() const;
    void _internal_set_channel_id(const std::string& value);
    std::string* _internal_mutable_channel_id();
    public:
  
    // string tx_id = 5;
    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);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_tx_id();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_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:
  
    // bytes extension = 7;
    void clear_extension();
    const std::string& extension() const;
    void set_extension(const std::string& value);
    void set_extension(std::string&& value);
    void set_extension(const char* value);
    void set_extension(const void* value, size_t size);
    std::string* mutable_extension();
    std::string* release_extension();
    void set_allocated_extension(std::string* extension);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_extension();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_set_allocated_extension(
        std::string* extension);
    private:
    const std::string& _internal_extension() const;
    void _internal_set_extension(const std::string& value);
    std::string* _internal_mutable_extension();
    public:
  
    // bytes tls_cert_hash = 8;
    void clear_tls_cert_hash();
    const std::string& tls_cert_hash() const;
    void set_tls_cert_hash(const std::string& value);
    void set_tls_cert_hash(std::string&& value);
    void set_tls_cert_hash(const char* value);
    void set_tls_cert_hash(const void* value, size_t size);
    std::string* mutable_tls_cert_hash();
    std::string* release_tls_cert_hash();
    void set_allocated_tls_cert_hash(std::string* tls_cert_hash);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_tls_cert_hash();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_set_allocated_tls_cert_hash(
        std::string* tls_cert_hash);
    private:
    const std::string& _internal_tls_cert_hash() const;
    void _internal_set_tls_cert_hash(const std::string& value);
    std::string* _internal_mutable_tls_cert_hash();
    public:
  
    // .google.protobuf.Timestamp timestamp = 3;
    bool has_timestamp() const;
    private:
    bool _internal_has_timestamp() const;
    public:
    void clear_timestamp();
    const PROTOBUF_NAMESPACE_ID::Timestamp& timestamp() const;
    PROTOBUF_NAMESPACE_ID::Timestamp* release_timestamp();
    PROTOBUF_NAMESPACE_ID::Timestamp* mutable_timestamp();
    void set_allocated_timestamp(PROTOBUF_NAMESPACE_ID::Timestamp* timestamp);
    private:
    const PROTOBUF_NAMESPACE_ID::Timestamp& _internal_timestamp() const;
    PROTOBUF_NAMESPACE_ID::Timestamp* _internal_mutable_timestamp();
    public:
    void unsafe_arena_set_allocated_timestamp(
        PROTOBUF_NAMESPACE_ID::Timestamp* timestamp);
    PROTOBUF_NAMESPACE_ID::Timestamp* unsafe_arena_release_timestamp();
  
    // int32 type = 1;
    void clear_type();
    ::PROTOBUF_NAMESPACE_ID::int32 type() const;
    void set_type(::PROTOBUF_NAMESPACE_ID::int32 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::int32 _internal_type() const;
    void _internal_set_type(::PROTOBUF_NAMESPACE_ID::int32 value);
    public:
  
    // int32 version = 2;
    void clear_version();
    ::PROTOBUF_NAMESPACE_ID::int32 version() const;
    void set_version(::PROTOBUF_NAMESPACE_ID::int32 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::int32 _internal_version() const;
    void _internal_set_version(::PROTOBUF_NAMESPACE_ID::int32 value);
    public:
  
    // uint64 epoch = 6;
    void clear_epoch();
    ::PROTOBUF_NAMESPACE_ID::uint64 epoch() const;
    void set_epoch(::PROTOBUF_NAMESPACE_ID::uint64 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::uint64 _internal_epoch() const;
    void _internal_set_epoch(::PROTOBUF_NAMESPACE_ID::uint64 value);
    public:
  
    // @@protoc_insertion_point(class_scope:common.ChannelHeader)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr channel_id_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tx_id_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr extension_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tls_cert_hash_;
    PROTOBUF_NAMESPACE_ID::Timestamp* timestamp_;
    ::PROTOBUF_NAMESPACE_ID::int32 type_;
    ::PROTOBUF_NAMESPACE_ID::int32 version_;
    ::PROTOBUF_NAMESPACE_ID::uint64 epoch_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2fcommon_2eproto;
  };
  // -------------------------------------------------------------------
  
  class SignatureHeader PROTOBUF_FINAL :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:common.SignatureHeader) */ {
   public:
    inline SignatureHeader() : SignatureHeader(nullptr) {};
    virtual ~SignatureHeader();
  
    SignatureHeader(const SignatureHeader& from);
    SignatureHeader(SignatureHeader&& from) noexcept
      : SignatureHeader() {
      *this = ::std::move(from);
    }
  
    inline SignatureHeader& operator=(const SignatureHeader& from) {
      CopyFrom(from);
      return *this;
    }
    inline SignatureHeader& operator=(SignatureHeader&& 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 SignatureHeader& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const SignatureHeader* internal_default_instance() {
      return reinterpret_cast<const SignatureHeader*>(
                 &_SignatureHeader_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      5;
  
    friend void swap(SignatureHeader& a, SignatureHeader& b) {
      a.Swap(&b);
    }
    inline void Swap(SignatureHeader* other) {
      if (other == this) return;
      if (GetArena() == other->GetArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(SignatureHeader* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetArena() == other->GetArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline SignatureHeader* New() const final {
      return CreateMaybeMessage<SignatureHeader>(nullptr);
    }
  
    SignatureHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<SignatureHeader>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const SignatureHeader& from);
    void MergeFrom(const SignatureHeader& 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(SignatureHeader* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "common.SignatureHeader";
    }
    protected:
    explicit SignatureHeader(::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() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2fcommon_2eproto);
      return ::descriptor_table_common_2fcommon_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kCreatorFieldNumber = 1,
      kNonceFieldNumber = 2,
    };
    // bytes creator = 1;
    void clear_creator();
    const std::string& creator() const;
    void set_creator(const std::string& value);
    void set_creator(std::string&& value);
    void set_creator(const char* value);
    void set_creator(const void* value, size_t size);
    std::string* mutable_creator();
    std::string* release_creator();
    void set_allocated_creator(std::string* creator);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_creator();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_set_allocated_creator(
        std::string* creator);
    private:
    const std::string& _internal_creator() const;
    void _internal_set_creator(const std::string& value);
    std::string* _internal_mutable_creator();
    public:
  
    // bytes nonce = 2;
    void clear_nonce();
    const std::string& nonce() const;
    void set_nonce(const std::string& value);
    void set_nonce(std::string&& value);
    void set_nonce(const char* value);
    void set_nonce(const void* value, size_t size);
    std::string* mutable_nonce();
    std::string* release_nonce();
    void set_allocated_nonce(std::string* nonce);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_nonce();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_set_allocated_nonce(
        std::string* nonce);
    private:
    const std::string& _internal_nonce() const;
    void _internal_set_nonce(const std::string& value);
    std::string* _internal_mutable_nonce();
    public:
  
    // @@protoc_insertion_point(class_scope:common.SignatureHeader)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr creator_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr nonce_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2fcommon_2eproto;
  };
  // -------------------------------------------------------------------
  
  class Payload PROTOBUF_FINAL :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:common.Payload) */ {
   public:
    inline Payload() : Payload(nullptr) {};
    virtual ~Payload();
  
    Payload(const Payload& from);
    Payload(Payload&& from) noexcept
      : Payload() {
      *this = ::std::move(from);
    }
  
    inline Payload& operator=(const Payload& from) {
      CopyFrom(from);
      return *this;
    }
    inline Payload& operator=(Payload&& 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 Payload& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const Payload* internal_default_instance() {
      return reinterpret_cast<const Payload*>(
                 &_Payload_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      6;
  
    friend void swap(Payload& a, Payload& b) {
      a.Swap(&b);
    }
    inline void Swap(Payload* other) {
      if (other == this) return;
      if (GetArena() == other->GetArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(Payload* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetArena() == other->GetArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline Payload* New() const final {
      return CreateMaybeMessage<Payload>(nullptr);
    }
  
    Payload* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<Payload>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const Payload& from);
    void MergeFrom(const Payload& 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(Payload* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "common.Payload";
    }
    protected:
    explicit Payload(::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() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2fcommon_2eproto);
      return ::descriptor_table_common_2fcommon_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kDataFieldNumber = 2,
      kHeaderFieldNumber = 1,
    };
    // bytes data = 2;
    void clear_data();
    const std::string& data() const;
    void set_data(const std::string& value);
    void set_data(std::string&& value);
    void set_data(const char* value);
    void set_data(const void* value, size_t size);
    std::string* mutable_data();
    std::string* release_data();
    void set_allocated_data(std::string* data);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_data();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_set_allocated_data(
        std::string* data);
    private:
    const std::string& _internal_data() const;
    void _internal_set_data(const std::string& value);
    std::string* _internal_mutable_data();
    public:
  
    // .common.Header header = 1;
    bool has_header() const;
    private:
    bool _internal_has_header() const;
    public:
    void clear_header();
    const ::common::Header& header() const;
    ::common::Header* release_header();
    ::common::Header* mutable_header();
    void set_allocated_header(::common::Header* header);
    private:
    const ::common::Header& _internal_header() const;
    ::common::Header* _internal_mutable_header();
    public:
    void unsafe_arena_set_allocated_header(
        ::common::Header* header);
    ::common::Header* unsafe_arena_release_header();
  
    // @@protoc_insertion_point(class_scope:common.Payload)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
    ::common::Header* header_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2fcommon_2eproto;
  };
  // -------------------------------------------------------------------
  
  class Envelope PROTOBUF_FINAL :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:common.Envelope) */ {
   public:
    inline Envelope() : Envelope(nullptr) {};
    virtual ~Envelope();
  
    Envelope(const Envelope& from);
    Envelope(Envelope&& from) noexcept
      : Envelope() {
      *this = ::std::move(from);
    }
  
    inline Envelope& operator=(const Envelope& from) {
      CopyFrom(from);
      return *this;
    }
    inline Envelope& operator=(Envelope&& 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 Envelope& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const Envelope* internal_default_instance() {
      return reinterpret_cast<const Envelope*>(
                 &_Envelope_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      7;
  
    friend void swap(Envelope& a, Envelope& b) {
      a.Swap(&b);
    }
    inline void Swap(Envelope* other) {
      if (other == this) return;
      if (GetArena() == other->GetArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(Envelope* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetArena() == other->GetArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline Envelope* New() const final {
      return CreateMaybeMessage<Envelope>(nullptr);
    }
  
    Envelope* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<Envelope>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const Envelope& from);
    void MergeFrom(const Envelope& 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(Envelope* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "common.Envelope";
    }
    protected:
    explicit Envelope(::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() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2fcommon_2eproto);
      return ::descriptor_table_common_2fcommon_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kPayloadFieldNumber = 1,
      kSignatureFieldNumber = 2,
    };
    // bytes payload = 1;
    void clear_payload();
    const std::string& payload() const;
    void set_payload(const std::string& value);
    void set_payload(std::string&& value);
    void set_payload(const char* value);
    void set_payload(const void* value, size_t size);
    std::string* mutable_payload();
    std::string* release_payload();
    void set_allocated_payload(std::string* payload);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_payload();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_set_allocated_payload(
        std::string* payload);
    private:
    const std::string& _internal_payload() const;
    void _internal_set_payload(const std::string& value);
    std::string* _internal_mutable_payload();
    public:
  
    // bytes signature = 2;
    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 void* value, size_t size);
    std::string* mutable_signature();
    std::string* release_signature();
    void set_allocated_signature(std::string* signature);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_signature();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_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:
  
    // @@protoc_insertion_point(class_scope:common.Envelope)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr payload_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2fcommon_2eproto;
  };
  // -------------------------------------------------------------------
  
  class Block PROTOBUF_FINAL :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:common.Block) */ {
   public:
    inline Block() : Block(nullptr) {};
    virtual ~Block();
  
    Block(const Block& from);
    Block(Block&& from) noexcept
      : Block() {
      *this = ::std::move(from);
    }
  
    inline Block& operator=(const Block& from) {
      CopyFrom(from);
      return *this;
    }
    inline Block& operator=(Block&& 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 Block& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const Block* internal_default_instance() {
      return reinterpret_cast<const Block*>(
                 &_Block_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      8;
  
    friend void swap(Block& a, Block& b) {
      a.Swap(&b);
    }
    inline void Swap(Block* other) {
      if (other == this) return;
      if (GetArena() == other->GetArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(Block* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetArena() == other->GetArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline Block* New() const final {
      return CreateMaybeMessage<Block>(nullptr);
    }
  
    Block* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<Block>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const Block& from);
    void MergeFrom(const Block& 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(Block* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "common.Block";
    }
    protected:
    explicit Block(::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() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2fcommon_2eproto);
      return ::descriptor_table_common_2fcommon_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kHeaderFieldNumber = 1,
      kDataFieldNumber = 2,
      kMetadataFieldNumber = 3,
    };
    // .common.BlockHeader header = 1;
    bool has_header() const;
    private:
    bool _internal_has_header() const;
    public:
    void clear_header();
    const ::common::BlockHeader& header() const;
    ::common::BlockHeader* release_header();
    ::common::BlockHeader* mutable_header();
    void set_allocated_header(::common::BlockHeader* header);
    private:
    const ::common::BlockHeader& _internal_header() const;
    ::common::BlockHeader* _internal_mutable_header();
    public:
    void unsafe_arena_set_allocated_header(
        ::common::BlockHeader* header);
    ::common::BlockHeader* unsafe_arena_release_header();
  
    // .common.BlockData data = 2;
    bool has_data() const;
    private:
    bool _internal_has_data() const;
    public:
    void clear_data();
    const ::common::BlockData& data() const;
    ::common::BlockData* release_data();
    ::common::BlockData* mutable_data();
    void set_allocated_data(::common::BlockData* data);
    private:
    const ::common::BlockData& _internal_data() const;
    ::common::BlockData* _internal_mutable_data();
    public:
    void unsafe_arena_set_allocated_data(
        ::common::BlockData* data);
    ::common::BlockData* unsafe_arena_release_data();
  
    // .common.BlockMetadata metadata = 3;
    bool has_metadata() const;
    private:
    bool _internal_has_metadata() const;
    public:
    void clear_metadata();
    const ::common::BlockMetadata& metadata() const;
    ::common::BlockMetadata* release_metadata();
    ::common::BlockMetadata* mutable_metadata();
    void set_allocated_metadata(::common::BlockMetadata* metadata);
    private:
    const ::common::BlockMetadata& _internal_metadata() const;
    ::common::BlockMetadata* _internal_mutable_metadata();
    public:
    void unsafe_arena_set_allocated_metadata(
        ::common::BlockMetadata* metadata);
    ::common::BlockMetadata* unsafe_arena_release_metadata();
  
    // @@protoc_insertion_point(class_scope:common.Block)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::common::BlockHeader* header_;
    ::common::BlockData* data_;
    ::common::BlockMetadata* metadata_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2fcommon_2eproto;
  };
  // -------------------------------------------------------------------
  
  class BlockHeader PROTOBUF_FINAL :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:common.BlockHeader) */ {
   public:
    inline BlockHeader() : BlockHeader(nullptr) {};
    virtual ~BlockHeader();
  
    BlockHeader(const BlockHeader& from);
    BlockHeader(BlockHeader&& from) noexcept
      : BlockHeader() {
      *this = ::std::move(from);
    }
  
    inline BlockHeader& operator=(const BlockHeader& from) {
      CopyFrom(from);
      return *this;
    }
    inline BlockHeader& operator=(BlockHeader&& 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 BlockHeader& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const BlockHeader* internal_default_instance() {
      return reinterpret_cast<const BlockHeader*>(
                 &_BlockHeader_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      9;
  
    friend void swap(BlockHeader& a, BlockHeader& b) {
      a.Swap(&b);
    }
    inline void Swap(BlockHeader* other) {
      if (other == this) return;
      if (GetArena() == other->GetArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(BlockHeader* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetArena() == other->GetArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline BlockHeader* New() const final {
      return CreateMaybeMessage<BlockHeader>(nullptr);
    }
  
    BlockHeader* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<BlockHeader>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const BlockHeader& from);
    void MergeFrom(const BlockHeader& 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(BlockHeader* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "common.BlockHeader";
    }
    protected:
    explicit BlockHeader(::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() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2fcommon_2eproto);
      return ::descriptor_table_common_2fcommon_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kPreviousHashFieldNumber = 2,
      kDataHashFieldNumber = 3,
      kNumberFieldNumber = 1,
    };
    // bytes previous_hash = 2;
    void clear_previous_hash();
    const std::string& previous_hash() const;
    void set_previous_hash(const std::string& value);
    void set_previous_hash(std::string&& value);
    void set_previous_hash(const char* value);
    void set_previous_hash(const void* value, size_t size);
    std::string* mutable_previous_hash();
    std::string* release_previous_hash();
    void set_allocated_previous_hash(std::string* previous_hash);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_previous_hash();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_set_allocated_previous_hash(
        std::string* previous_hash);
    private:
    const std::string& _internal_previous_hash() const;
    void _internal_set_previous_hash(const std::string& value);
    std::string* _internal_mutable_previous_hash();
    public:
  
    // bytes data_hash = 3;
    void clear_data_hash();
    const std::string& data_hash() const;
    void set_data_hash(const std::string& value);
    void set_data_hash(std::string&& value);
    void set_data_hash(const char* value);
    void set_data_hash(const void* value, size_t size);
    std::string* mutable_data_hash();
    std::string* release_data_hash();
    void set_allocated_data_hash(std::string* data_hash);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_data_hash();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_set_allocated_data_hash(
        std::string* data_hash);
    private:
    const std::string& _internal_data_hash() const;
    void _internal_set_data_hash(const std::string& value);
    std::string* _internal_mutable_data_hash();
    public:
  
    // uint64 number = 1;
    void clear_number();
    ::PROTOBUF_NAMESPACE_ID::uint64 number() const;
    void set_number(::PROTOBUF_NAMESPACE_ID::uint64 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::uint64 _internal_number() const;
    void _internal_set_number(::PROTOBUF_NAMESPACE_ID::uint64 value);
    public:
  
    // @@protoc_insertion_point(class_scope:common.BlockHeader)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr previous_hash_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_hash_;
    ::PROTOBUF_NAMESPACE_ID::uint64 number_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2fcommon_2eproto;
  };
  // -------------------------------------------------------------------
  
  class BlockData PROTOBUF_FINAL :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:common.BlockData) */ {
   public:
    inline BlockData() : BlockData(nullptr) {};
    virtual ~BlockData();
  
    BlockData(const BlockData& from);
    BlockData(BlockData&& from) noexcept
      : BlockData() {
      *this = ::std::move(from);
    }
  
    inline BlockData& operator=(const BlockData& from) {
      CopyFrom(from);
      return *this;
    }
    inline BlockData& operator=(BlockData&& 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 BlockData& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const BlockData* internal_default_instance() {
      return reinterpret_cast<const BlockData*>(
                 &_BlockData_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      10;
  
    friend void swap(BlockData& a, BlockData& b) {
      a.Swap(&b);
    }
    inline void Swap(BlockData* other) {
      if (other == this) return;
      if (GetArena() == other->GetArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(BlockData* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetArena() == other->GetArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline BlockData* New() const final {
      return CreateMaybeMessage<BlockData>(nullptr);
    }
  
    BlockData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<BlockData>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const BlockData& from);
    void MergeFrom(const BlockData& 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(BlockData* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "common.BlockData";
    }
    protected:
    explicit BlockData(::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() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2fcommon_2eproto);
      return ::descriptor_table_common_2fcommon_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kDataFieldNumber = 1,
    };
    // repeated bytes data = 1;
    int data_size() const;
    private:
    int _internal_data_size() const;
    public:
    void clear_data();
    const std::string& data(int index) const;
    std::string* mutable_data(int index);
    void set_data(int index, const std::string& value);
    void set_data(int index, std::string&& value);
    void set_data(int index, const char* value);
    void set_data(int index, const void* value, size_t size);
    std::string* add_data();
    void add_data(const std::string& value);
    void add_data(std::string&& value);
    void add_data(const char* value);
    void add_data(const void* value, size_t size);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& data() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_data();
    private:
    const std::string& _internal_data(int index) const;
    std::string* _internal_add_data();
    public:
  
    // @@protoc_insertion_point(class_scope:common.BlockData)
   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> data_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2fcommon_2eproto;
  };
  // -------------------------------------------------------------------
  
  class BlockMetadata PROTOBUF_FINAL :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:common.BlockMetadata) */ {
   public:
    inline BlockMetadata() : BlockMetadata(nullptr) {};
    virtual ~BlockMetadata();
  
    BlockMetadata(const BlockMetadata& from);
    BlockMetadata(BlockMetadata&& from) noexcept
      : BlockMetadata() {
      *this = ::std::move(from);
    }
  
    inline BlockMetadata& operator=(const BlockMetadata& from) {
      CopyFrom(from);
      return *this;
    }
    inline BlockMetadata& operator=(BlockMetadata&& 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 BlockMetadata& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const BlockMetadata* internal_default_instance() {
      return reinterpret_cast<const BlockMetadata*>(
                 &_BlockMetadata_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      11;
  
    friend void swap(BlockMetadata& a, BlockMetadata& b) {
      a.Swap(&b);
    }
    inline void Swap(BlockMetadata* other) {
      if (other == this) return;
      if (GetArena() == other->GetArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(BlockMetadata* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetArena() == other->GetArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline BlockMetadata* New() const final {
      return CreateMaybeMessage<BlockMetadata>(nullptr);
    }
  
    BlockMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<BlockMetadata>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const BlockMetadata& from);
    void MergeFrom(const BlockMetadata& 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(BlockMetadata* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "common.BlockMetadata";
    }
    protected:
    explicit BlockMetadata(::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() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2fcommon_2eproto);
      return ::descriptor_table_common_2fcommon_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kMetadataFieldNumber = 1,
    };
    // repeated bytes metadata = 1;
    int metadata_size() const;
    private:
    int _internal_metadata_size() const;
    public:
    void clear_metadata();
    const std::string& metadata(int index) const;
    std::string* mutable_metadata(int index);
    void set_metadata(int index, const std::string& value);
    void set_metadata(int index, std::string&& value);
    void set_metadata(int index, const char* value);
    void set_metadata(int index, const void* value, size_t size);
    std::string* add_metadata();
    void add_metadata(const std::string& value);
    void add_metadata(std::string&& value);
    void add_metadata(const char* value);
    void add_metadata(const void* value, size_t size);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& metadata() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_metadata();
    private:
    const std::string& _internal_metadata(int index) const;
    std::string* _internal_add_metadata();
    public:
  
    // @@protoc_insertion_point(class_scope:common.BlockMetadata)
   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> metadata_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2fcommon_2eproto;
  };
  // -------------------------------------------------------------------
  
  class OrdererBlockMetadata PROTOBUF_FINAL :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:common.OrdererBlockMetadata) */ {
   public:
    inline OrdererBlockMetadata() : OrdererBlockMetadata(nullptr) {};
    virtual ~OrdererBlockMetadata();
  
    OrdererBlockMetadata(const OrdererBlockMetadata& from);
    OrdererBlockMetadata(OrdererBlockMetadata&& from) noexcept
      : OrdererBlockMetadata() {
      *this = ::std::move(from);
    }
  
    inline OrdererBlockMetadata& operator=(const OrdererBlockMetadata& from) {
      CopyFrom(from);
      return *this;
    }
    inline OrdererBlockMetadata& operator=(OrdererBlockMetadata&& 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 OrdererBlockMetadata& default_instance();
  
    static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
    static inline const OrdererBlockMetadata* internal_default_instance() {
      return reinterpret_cast<const OrdererBlockMetadata*>(
                 &_OrdererBlockMetadata_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      12;
  
    friend void swap(OrdererBlockMetadata& a, OrdererBlockMetadata& b) {
      a.Swap(&b);
    }
    inline void Swap(OrdererBlockMetadata* other) {
      if (other == this) return;
      if (GetArena() == other->GetArena()) {
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(OrdererBlockMetadata* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetArena() == other->GetArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline OrdererBlockMetadata* New() const final {
      return CreateMaybeMessage<OrdererBlockMetadata>(nullptr);
    }
  
    OrdererBlockMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<OrdererBlockMetadata>(arena);
    }
    void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
    void CopyFrom(const OrdererBlockMetadata& from);
    void MergeFrom(const OrdererBlockMetadata& 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(OrdererBlockMetadata* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "common.OrdererBlockMetadata";
    }
    protected:
    explicit OrdererBlockMetadata(::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() {
      ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_common_2fcommon_2eproto);
      return ::descriptor_table_common_2fcommon_2eproto.file_level_metadata[kIndexInFileMessages];
    }
  
    public:
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kConsenterMetadataFieldNumber = 2,
      kLastConfigFieldNumber = 1,
    };
    // bytes consenter_metadata = 2;
    void clear_consenter_metadata();
    const std::string& consenter_metadata() const;
    void set_consenter_metadata(const std::string& value);
    void set_consenter_metadata(std::string&& value);
    void set_consenter_metadata(const char* value);
    void set_consenter_metadata(const void* value, size_t size);
    std::string* mutable_consenter_metadata();
    std::string* release_consenter_metadata();
    void set_allocated_consenter_metadata(std::string* consenter_metadata);
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    std::string* unsafe_arena_release_consenter_metadata();
    GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
    "    string fields are deprecated and will be removed in a"
    "    future release.")
    void unsafe_arena_set_allocated_consenter_metadata(
        std::string* consenter_metadata);
    private:
    const std::string& _internal_consenter_metadata() const;
    void _internal_set_consenter_metadata(const std::string& value);
    std::string* _internal_mutable_consenter_metadata();
    public:
  
    // .common.LastConfig last_config = 1;
    bool has_last_config() const;
    private:
    bool _internal_has_last_config() const;
    public:
    void clear_last_config();
    const ::common::LastConfig& last_config() const;
    ::common::LastConfig* release_last_config();
    ::common::LastConfig* mutable_last_config();
    void set_allocated_last_config(::common::LastConfig* last_config);
    private:
    const ::common::LastConfig& _internal_last_config() const;
    ::common::LastConfig* _internal_mutable_last_config();
    public:
    void unsafe_arena_set_allocated_last_config(
        ::common::LastConfig* last_config);
    ::common::LastConfig* unsafe_arena_release_last_config();
  
    // @@protoc_insertion_point(class_scope:common.OrdererBlockMetadata)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr consenter_metadata_;
    ::common::LastConfig* last_config_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_common_2fcommon_2eproto;
  };
  // ===================================================================
  
  
  // ===================================================================
  
  #ifdef __GNUC__
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wstrict-aliasing"
  #endif  // __GNUC__
  // LastConfig
  
  // uint64 index = 1;
  inline void LastConfig::clear_index() {
    index_ = PROTOBUF_ULONGLONG(0);
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 LastConfig::_internal_index() const {
    return index_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 LastConfig::index() const {
    // @@protoc_insertion_point(field_get:common.LastConfig.index)
    return _internal_index();
  }
  inline void LastConfig::_internal_set_index(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    
    index_ = value;
  }
  inline void LastConfig::set_index(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    _internal_set_index(value);
    // @@protoc_insertion_point(field_set:common.LastConfig.index)
  }
  
  // -------------------------------------------------------------------
  
  // Metadata
  
  // bytes value = 1;
  inline void Metadata::clear_value() {
    value_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& Metadata::value() const {
    // @@protoc_insertion_point(field_get:common.Metadata.value)
    return _internal_value();
  }
  inline void Metadata::set_value(const std::string& value) {
    _internal_set_value(value);
    // @@protoc_insertion_point(field_set:common.Metadata.value)
  }
  inline std::string* Metadata::mutable_value() {
    // @@protoc_insertion_point(field_mutable:common.Metadata.value)
    return _internal_mutable_value();
  }
  inline const std::string& Metadata::_internal_value() const {
    return value_.Get();
  }
  inline void Metadata::_internal_set_value(const std::string& value) {
    
    value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void Metadata::set_value(std::string&& value) {
    
    value_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.Metadata.value)
  }
  inline void Metadata::set_value(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.Metadata.value)
  }
  inline void Metadata::set_value(const void* value,
      size_t size) {
    
    value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.Metadata.value)
  }
  inline std::string* Metadata::_internal_mutable_value() {
    
    return value_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* Metadata::release_value() {
    // @@protoc_insertion_point(field_release:common.Metadata.value)
    return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void Metadata::set_allocated_value(std::string* value) {
    if (value != nullptr) {
      
    } else {
      
    }
    value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value,
        GetArena());
    // @@protoc_insertion_point(field_set_allocated:common.Metadata.value)
  }
  inline std::string* Metadata::unsafe_arena_release_value() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.Metadata.value)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return value_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void Metadata::unsafe_arena_set_allocated_value(
      std::string* value) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (value != nullptr) {
      
    } else {
      
    }
    value_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        value, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.Metadata.value)
  }
  
  // repeated .common.MetadataSignature signatures = 2;
  inline int Metadata::_internal_signatures_size() const {
    return signatures_.size();
  }
  inline int Metadata::signatures_size() const {
    return _internal_signatures_size();
  }
  inline void Metadata::clear_signatures() {
    signatures_.Clear();
  }
  inline ::common::MetadataSignature* Metadata::mutable_signatures(int index) {
    // @@protoc_insertion_point(field_mutable:common.Metadata.signatures)
    return signatures_.Mutable(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::common::MetadataSignature >*
  Metadata::mutable_signatures() {
    // @@protoc_insertion_point(field_mutable_list:common.Metadata.signatures)
    return &signatures_;
  }
  inline const ::common::MetadataSignature& Metadata::_internal_signatures(int index) const {
    return signatures_.Get(index);
  }
  inline const ::common::MetadataSignature& Metadata::signatures(int index) const {
    // @@protoc_insertion_point(field_get:common.Metadata.signatures)
    return _internal_signatures(index);
  }
  inline ::common::MetadataSignature* Metadata::_internal_add_signatures() {
    return signatures_.Add();
  }
  inline ::common::MetadataSignature* Metadata::add_signatures() {
    // @@protoc_insertion_point(field_add:common.Metadata.signatures)
    return _internal_add_signatures();
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::common::MetadataSignature >&
  Metadata::signatures() const {
    // @@protoc_insertion_point(field_list:common.Metadata.signatures)
    return signatures_;
  }
  
  // -------------------------------------------------------------------
  
  // MetadataSignature
  
  // bytes signature_header = 1;
  inline void MetadataSignature::clear_signature_header() {
    signature_header_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& MetadataSignature::signature_header() const {
    // @@protoc_insertion_point(field_get:common.MetadataSignature.signature_header)
    return _internal_signature_header();
  }
  inline void MetadataSignature::set_signature_header(const std::string& value) {
    _internal_set_signature_header(value);
    // @@protoc_insertion_point(field_set:common.MetadataSignature.signature_header)
  }
  inline std::string* MetadataSignature::mutable_signature_header() {
    // @@protoc_insertion_point(field_mutable:common.MetadataSignature.signature_header)
    return _internal_mutable_signature_header();
  }
  inline const std::string& MetadataSignature::_internal_signature_header() const {
    return signature_header_.Get();
  }
  inline void MetadataSignature::_internal_set_signature_header(const std::string& value) {
    
    signature_header_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void MetadataSignature::set_signature_header(std::string&& value) {
    
    signature_header_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.MetadataSignature.signature_header)
  }
  inline void MetadataSignature::set_signature_header(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    signature_header_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.MetadataSignature.signature_header)
  }
  inline void MetadataSignature::set_signature_header(const void* value,
      size_t size) {
    
    signature_header_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.MetadataSignature.signature_header)
  }
  inline std::string* MetadataSignature::_internal_mutable_signature_header() {
    
    return signature_header_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* MetadataSignature::release_signature_header() {
    // @@protoc_insertion_point(field_release:common.MetadataSignature.signature_header)
    return signature_header_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void MetadataSignature::set_allocated_signature_header(std::string* signature_header) {
    if (signature_header != nullptr) {
      
    } else {
      
    }
    signature_header_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature_header,
        GetArena());
    // @@protoc_insertion_point(field_set_allocated:common.MetadataSignature.signature_header)
  }
  inline std::string* MetadataSignature::unsafe_arena_release_signature_header() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.MetadataSignature.signature_header)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return signature_header_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void MetadataSignature::unsafe_arena_set_allocated_signature_header(
      std::string* signature_header) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (signature_header != nullptr) {
      
    } else {
      
    }
    signature_header_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        signature_header, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.MetadataSignature.signature_header)
  }
  
  // bytes signature = 2;
  inline void MetadataSignature::clear_signature() {
    signature_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& MetadataSignature::signature() const {
    // @@protoc_insertion_point(field_get:common.MetadataSignature.signature)
    return _internal_signature();
  }
  inline void MetadataSignature::set_signature(const std::string& value) {
    _internal_set_signature(value);
    // @@protoc_insertion_point(field_set:common.MetadataSignature.signature)
  }
  inline std::string* MetadataSignature::mutable_signature() {
    // @@protoc_insertion_point(field_mutable:common.MetadataSignature.signature)
    return _internal_mutable_signature();
  }
  inline const std::string& MetadataSignature::_internal_signature() const {
    return signature_.Get();
  }
  inline void MetadataSignature::_internal_set_signature(const std::string& value) {
    
    signature_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void MetadataSignature::set_signature(std::string&& value) {
    
    signature_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.MetadataSignature.signature)
  }
  inline void MetadataSignature::set_signature(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    signature_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.MetadataSignature.signature)
  }
  inline void MetadataSignature::set_signature(const void* value,
      size_t size) {
    
    signature_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.MetadataSignature.signature)
  }
  inline std::string* MetadataSignature::_internal_mutable_signature() {
    
    return signature_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* MetadataSignature::release_signature() {
    // @@protoc_insertion_point(field_release:common.MetadataSignature.signature)
    return signature_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void MetadataSignature::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:common.MetadataSignature.signature)
  }
  inline std::string* MetadataSignature::unsafe_arena_release_signature() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.MetadataSignature.signature)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return signature_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void MetadataSignature::unsafe_arena_set_allocated_signature(
      std::string* signature) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (signature != nullptr) {
      
    } else {
      
    }
    signature_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        signature, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.MetadataSignature.signature)
  }
  
  // -------------------------------------------------------------------
  
  // Header
  
  // bytes channel_header = 1;
  inline void Header::clear_channel_header() {
    channel_header_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& Header::channel_header() const {
    // @@protoc_insertion_point(field_get:common.Header.channel_header)
    return _internal_channel_header();
  }
  inline void Header::set_channel_header(const std::string& value) {
    _internal_set_channel_header(value);
    // @@protoc_insertion_point(field_set:common.Header.channel_header)
  }
  inline std::string* Header::mutable_channel_header() {
    // @@protoc_insertion_point(field_mutable:common.Header.channel_header)
    return _internal_mutable_channel_header();
  }
  inline const std::string& Header::_internal_channel_header() const {
    return channel_header_.Get();
  }
  inline void Header::_internal_set_channel_header(const std::string& value) {
    
    channel_header_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void Header::set_channel_header(std::string&& value) {
    
    channel_header_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.Header.channel_header)
  }
  inline void Header::set_channel_header(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    channel_header_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.Header.channel_header)
  }
  inline void Header::set_channel_header(const void* value,
      size_t size) {
    
    channel_header_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.Header.channel_header)
  }
  inline std::string* Header::_internal_mutable_channel_header() {
    
    return channel_header_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* Header::release_channel_header() {
    // @@protoc_insertion_point(field_release:common.Header.channel_header)
    return channel_header_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void Header::set_allocated_channel_header(std::string* channel_header) {
    if (channel_header != nullptr) {
      
    } else {
      
    }
    channel_header_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), channel_header,
        GetArena());
    // @@protoc_insertion_point(field_set_allocated:common.Header.channel_header)
  }
  inline std::string* Header::unsafe_arena_release_channel_header() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.Header.channel_header)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return channel_header_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void Header::unsafe_arena_set_allocated_channel_header(
      std::string* channel_header) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (channel_header != nullptr) {
      
    } else {
      
    }
    channel_header_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        channel_header, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.Header.channel_header)
  }
  
  // bytes signature_header = 2;
  inline void Header::clear_signature_header() {
    signature_header_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& Header::signature_header() const {
    // @@protoc_insertion_point(field_get:common.Header.signature_header)
    return _internal_signature_header();
  }
  inline void Header::set_signature_header(const std::string& value) {
    _internal_set_signature_header(value);
    // @@protoc_insertion_point(field_set:common.Header.signature_header)
  }
  inline std::string* Header::mutable_signature_header() {
    // @@protoc_insertion_point(field_mutable:common.Header.signature_header)
    return _internal_mutable_signature_header();
  }
  inline const std::string& Header::_internal_signature_header() const {
    return signature_header_.Get();
  }
  inline void Header::_internal_set_signature_header(const std::string& value) {
    
    signature_header_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void Header::set_signature_header(std::string&& value) {
    
    signature_header_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.Header.signature_header)
  }
  inline void Header::set_signature_header(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    signature_header_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.Header.signature_header)
  }
  inline void Header::set_signature_header(const void* value,
      size_t size) {
    
    signature_header_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.Header.signature_header)
  }
  inline std::string* Header::_internal_mutable_signature_header() {
    
    return signature_header_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* Header::release_signature_header() {
    // @@protoc_insertion_point(field_release:common.Header.signature_header)
    return signature_header_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void Header::set_allocated_signature_header(std::string* signature_header) {
    if (signature_header != nullptr) {
      
    } else {
      
    }
    signature_header_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature_header,
        GetArena());
    // @@protoc_insertion_point(field_set_allocated:common.Header.signature_header)
  }
  inline std::string* Header::unsafe_arena_release_signature_header() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.Header.signature_header)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return signature_header_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void Header::unsafe_arena_set_allocated_signature_header(
      std::string* signature_header) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (signature_header != nullptr) {
      
    } else {
      
    }
    signature_header_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        signature_header, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.Header.signature_header)
  }
  
  // -------------------------------------------------------------------
  
  // ChannelHeader
  
  // int32 type = 1;
  inline void ChannelHeader::clear_type() {
    type_ = 0;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 ChannelHeader::_internal_type() const {
    return type_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 ChannelHeader::type() const {
    // @@protoc_insertion_point(field_get:common.ChannelHeader.type)
    return _internal_type();
  }
  inline void ChannelHeader::_internal_set_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
    
    type_ = value;
  }
  inline void ChannelHeader::set_type(::PROTOBUF_NAMESPACE_ID::int32 value) {
    _internal_set_type(value);
    // @@protoc_insertion_point(field_set:common.ChannelHeader.type)
  }
  
  // int32 version = 2;
  inline void ChannelHeader::clear_version() {
    version_ = 0;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 ChannelHeader::_internal_version() const {
    return version_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 ChannelHeader::version() const {
    // @@protoc_insertion_point(field_get:common.ChannelHeader.version)
    return _internal_version();
  }
  inline void ChannelHeader::_internal_set_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
    
    version_ = value;
  }
  inline void ChannelHeader::set_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
    _internal_set_version(value);
    // @@protoc_insertion_point(field_set:common.ChannelHeader.version)
  }
  
  // .google.protobuf.Timestamp timestamp = 3;
  inline bool ChannelHeader::_internal_has_timestamp() const {
    return this != internal_default_instance() && timestamp_ != nullptr;
  }
  inline bool ChannelHeader::has_timestamp() const {
    return _internal_has_timestamp();
  }
  inline const PROTOBUF_NAMESPACE_ID::Timestamp& ChannelHeader::_internal_timestamp() const {
    const PROTOBUF_NAMESPACE_ID::Timestamp* p = timestamp_;
    return p != nullptr ? *p : *reinterpret_cast<const PROTOBUF_NAMESPACE_ID::Timestamp*>(
        &PROTOBUF_NAMESPACE_ID::_Timestamp_default_instance_);
  }
  inline const PROTOBUF_NAMESPACE_ID::Timestamp& ChannelHeader::timestamp() const {
    // @@protoc_insertion_point(field_get:common.ChannelHeader.timestamp)
    return _internal_timestamp();
  }
  inline void ChannelHeader::unsafe_arena_set_allocated_timestamp(
      PROTOBUF_NAMESPACE_ID::Timestamp* 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:common.ChannelHeader.timestamp)
  }
  inline PROTOBUF_NAMESPACE_ID::Timestamp* ChannelHeader::release_timestamp() {
    auto temp = unsafe_arena_release_timestamp();
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    return temp;
  }
  inline PROTOBUF_NAMESPACE_ID::Timestamp* ChannelHeader::unsafe_arena_release_timestamp() {
    // @@protoc_insertion_point(field_release:common.ChannelHeader.timestamp)
    
    PROTOBUF_NAMESPACE_ID::Timestamp* temp = timestamp_;
    timestamp_ = nullptr;
    return temp;
  }
  inline PROTOBUF_NAMESPACE_ID::Timestamp* ChannelHeader::_internal_mutable_timestamp() {
    
    if (timestamp_ == nullptr) {
      auto* p = CreateMaybeMessage<PROTOBUF_NAMESPACE_ID::Timestamp>(GetArena());
      timestamp_ = p;
    }
    return timestamp_;
  }
  inline PROTOBUF_NAMESPACE_ID::Timestamp* ChannelHeader::mutable_timestamp() {
    // @@protoc_insertion_point(field_mutable:common.ChannelHeader.timestamp)
    return _internal_mutable_timestamp();
  }
  inline void ChannelHeader::set_allocated_timestamp(PROTOBUF_NAMESPACE_ID::Timestamp* timestamp) {
    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
    if (message_arena == nullptr) {
      delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp_);
    }
    if (timestamp) {
      ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp)->GetArena();
      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:common.ChannelHeader.timestamp)
  }
  
  // string channel_id = 4;
  inline void ChannelHeader::clear_channel_id() {
    channel_id_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& ChannelHeader::channel_id() const {
    // @@protoc_insertion_point(field_get:common.ChannelHeader.channel_id)
    return _internal_channel_id();
  }
  inline void ChannelHeader::set_channel_id(const std::string& value) {
    _internal_set_channel_id(value);
    // @@protoc_insertion_point(field_set:common.ChannelHeader.channel_id)
  }
  inline std::string* ChannelHeader::mutable_channel_id() {
    // @@protoc_insertion_point(field_mutable:common.ChannelHeader.channel_id)
    return _internal_mutable_channel_id();
  }
  inline const std::string& ChannelHeader::_internal_channel_id() const {
    return channel_id_.Get();
  }
  inline void ChannelHeader::_internal_set_channel_id(const std::string& value) {
    
    channel_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void ChannelHeader::set_channel_id(std::string&& value) {
    
    channel_id_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.ChannelHeader.channel_id)
  }
  inline void ChannelHeader::set_channel_id(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    channel_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.ChannelHeader.channel_id)
  }
  inline void ChannelHeader::set_channel_id(const char* value,
      size_t size) {
    
    channel_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.ChannelHeader.channel_id)
  }
  inline std::string* ChannelHeader::_internal_mutable_channel_id() {
    
    return channel_id_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* ChannelHeader::release_channel_id() {
    // @@protoc_insertion_point(field_release:common.ChannelHeader.channel_id)
    return channel_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void ChannelHeader::set_allocated_channel_id(std::string* channel_id) {
    if (channel_id != nullptr) {
      
    } else {
      
    }
    channel_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), channel_id,
        GetArena());
    // @@protoc_insertion_point(field_set_allocated:common.ChannelHeader.channel_id)
  }
  inline std::string* ChannelHeader::unsafe_arena_release_channel_id() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.ChannelHeader.channel_id)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return channel_id_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void ChannelHeader::unsafe_arena_set_allocated_channel_id(
      std::string* channel_id) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (channel_id != nullptr) {
      
    } else {
      
    }
    channel_id_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        channel_id, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.ChannelHeader.channel_id)
  }
  
  // string tx_id = 5;
  inline void ChannelHeader::clear_tx_id() {
    tx_id_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& ChannelHeader::tx_id() const {
    // @@protoc_insertion_point(field_get:common.ChannelHeader.tx_id)
    return _internal_tx_id();
  }
  inline void ChannelHeader::set_tx_id(const std::string& value) {
    _internal_set_tx_id(value);
    // @@protoc_insertion_point(field_set:common.ChannelHeader.tx_id)
  }
  inline std::string* ChannelHeader::mutable_tx_id() {
    // @@protoc_insertion_point(field_mutable:common.ChannelHeader.tx_id)
    return _internal_mutable_tx_id();
  }
  inline const std::string& ChannelHeader::_internal_tx_id() const {
    return tx_id_.Get();
  }
  inline void ChannelHeader::_internal_set_tx_id(const std::string& value) {
    
    tx_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void ChannelHeader::set_tx_id(std::string&& value) {
    
    tx_id_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.ChannelHeader.tx_id)
  }
  inline void ChannelHeader::set_tx_id(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    tx_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.ChannelHeader.tx_id)
  }
  inline void ChannelHeader::set_tx_id(const char* value,
      size_t size) {
    
    tx_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.ChannelHeader.tx_id)
  }
  inline std::string* ChannelHeader::_internal_mutable_tx_id() {
    
    return tx_id_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* ChannelHeader::release_tx_id() {
    // @@protoc_insertion_point(field_release:common.ChannelHeader.tx_id)
    return tx_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void ChannelHeader::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:common.ChannelHeader.tx_id)
  }
  inline std::string* ChannelHeader::unsafe_arena_release_tx_id() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.ChannelHeader.tx_id)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return tx_id_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void ChannelHeader::unsafe_arena_set_allocated_tx_id(
      std::string* tx_id) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (tx_id != nullptr) {
      
    } else {
      
    }
    tx_id_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        tx_id, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.ChannelHeader.tx_id)
  }
  
  // uint64 epoch = 6;
  inline void ChannelHeader::clear_epoch() {
    epoch_ = PROTOBUF_ULONGLONG(0);
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 ChannelHeader::_internal_epoch() const {
    return epoch_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 ChannelHeader::epoch() const {
    // @@protoc_insertion_point(field_get:common.ChannelHeader.epoch)
    return _internal_epoch();
  }
  inline void ChannelHeader::_internal_set_epoch(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    
    epoch_ = value;
  }
  inline void ChannelHeader::set_epoch(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    _internal_set_epoch(value);
    // @@protoc_insertion_point(field_set:common.ChannelHeader.epoch)
  }
  
  // bytes extension = 7;
  inline void ChannelHeader::clear_extension() {
    extension_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& ChannelHeader::extension() const {
    // @@protoc_insertion_point(field_get:common.ChannelHeader.extension)
    return _internal_extension();
  }
  inline void ChannelHeader::set_extension(const std::string& value) {
    _internal_set_extension(value);
    // @@protoc_insertion_point(field_set:common.ChannelHeader.extension)
  }
  inline std::string* ChannelHeader::mutable_extension() {
    // @@protoc_insertion_point(field_mutable:common.ChannelHeader.extension)
    return _internal_mutable_extension();
  }
  inline const std::string& ChannelHeader::_internal_extension() const {
    return extension_.Get();
  }
  inline void ChannelHeader::_internal_set_extension(const std::string& value) {
    
    extension_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void ChannelHeader::set_extension(std::string&& value) {
    
    extension_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.ChannelHeader.extension)
  }
  inline void ChannelHeader::set_extension(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    extension_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.ChannelHeader.extension)
  }
  inline void ChannelHeader::set_extension(const void* value,
      size_t size) {
    
    extension_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.ChannelHeader.extension)
  }
  inline std::string* ChannelHeader::_internal_mutable_extension() {
    
    return extension_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* ChannelHeader::release_extension() {
    // @@protoc_insertion_point(field_release:common.ChannelHeader.extension)
    return extension_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void ChannelHeader::set_allocated_extension(std::string* extension) {
    if (extension != nullptr) {
      
    } else {
      
    }
    extension_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), extension,
        GetArena());
    // @@protoc_insertion_point(field_set_allocated:common.ChannelHeader.extension)
  }
  inline std::string* ChannelHeader::unsafe_arena_release_extension() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.ChannelHeader.extension)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return extension_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void ChannelHeader::unsafe_arena_set_allocated_extension(
      std::string* extension) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (extension != nullptr) {
      
    } else {
      
    }
    extension_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        extension, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.ChannelHeader.extension)
  }
  
  // bytes tls_cert_hash = 8;
  inline void ChannelHeader::clear_tls_cert_hash() {
    tls_cert_hash_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& ChannelHeader::tls_cert_hash() const {
    // @@protoc_insertion_point(field_get:common.ChannelHeader.tls_cert_hash)
    return _internal_tls_cert_hash();
  }
  inline void ChannelHeader::set_tls_cert_hash(const std::string& value) {
    _internal_set_tls_cert_hash(value);
    // @@protoc_insertion_point(field_set:common.ChannelHeader.tls_cert_hash)
  }
  inline std::string* ChannelHeader::mutable_tls_cert_hash() {
    // @@protoc_insertion_point(field_mutable:common.ChannelHeader.tls_cert_hash)
    return _internal_mutable_tls_cert_hash();
  }
  inline const std::string& ChannelHeader::_internal_tls_cert_hash() const {
    return tls_cert_hash_.Get();
  }
  inline void ChannelHeader::_internal_set_tls_cert_hash(const std::string& value) {
    
    tls_cert_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void ChannelHeader::set_tls_cert_hash(std::string&& value) {
    
    tls_cert_hash_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.ChannelHeader.tls_cert_hash)
  }
  inline void ChannelHeader::set_tls_cert_hash(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    tls_cert_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.ChannelHeader.tls_cert_hash)
  }
  inline void ChannelHeader::set_tls_cert_hash(const void* value,
      size_t size) {
    
    tls_cert_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.ChannelHeader.tls_cert_hash)
  }
  inline std::string* ChannelHeader::_internal_mutable_tls_cert_hash() {
    
    return tls_cert_hash_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* ChannelHeader::release_tls_cert_hash() {
    // @@protoc_insertion_point(field_release:common.ChannelHeader.tls_cert_hash)
    return tls_cert_hash_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void ChannelHeader::set_allocated_tls_cert_hash(std::string* tls_cert_hash) {
    if (tls_cert_hash != nullptr) {
      
    } else {
      
    }
    tls_cert_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tls_cert_hash,
        GetArena());
    // @@protoc_insertion_point(field_set_allocated:common.ChannelHeader.tls_cert_hash)
  }
  inline std::string* ChannelHeader::unsafe_arena_release_tls_cert_hash() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.ChannelHeader.tls_cert_hash)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return tls_cert_hash_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void ChannelHeader::unsafe_arena_set_allocated_tls_cert_hash(
      std::string* tls_cert_hash) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (tls_cert_hash != nullptr) {
      
    } else {
      
    }
    tls_cert_hash_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        tls_cert_hash, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.ChannelHeader.tls_cert_hash)
  }
  
  // -------------------------------------------------------------------
  
  // SignatureHeader
  
  // bytes creator = 1;
  inline void SignatureHeader::clear_creator() {
    creator_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& SignatureHeader::creator() const {
    // @@protoc_insertion_point(field_get:common.SignatureHeader.creator)
    return _internal_creator();
  }
  inline void SignatureHeader::set_creator(const std::string& value) {
    _internal_set_creator(value);
    // @@protoc_insertion_point(field_set:common.SignatureHeader.creator)
  }
  inline std::string* SignatureHeader::mutable_creator() {
    // @@protoc_insertion_point(field_mutable:common.SignatureHeader.creator)
    return _internal_mutable_creator();
  }
  inline const std::string& SignatureHeader::_internal_creator() const {
    return creator_.Get();
  }
  inline void SignatureHeader::_internal_set_creator(const std::string& value) {
    
    creator_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void SignatureHeader::set_creator(std::string&& value) {
    
    creator_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.SignatureHeader.creator)
  }
  inline void SignatureHeader::set_creator(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    creator_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.SignatureHeader.creator)
  }
  inline void SignatureHeader::set_creator(const void* value,
      size_t size) {
    
    creator_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.SignatureHeader.creator)
  }
  inline std::string* SignatureHeader::_internal_mutable_creator() {
    
    return creator_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* SignatureHeader::release_creator() {
    // @@protoc_insertion_point(field_release:common.SignatureHeader.creator)
    return creator_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void SignatureHeader::set_allocated_creator(std::string* creator) {
    if (creator != nullptr) {
      
    } else {
      
    }
    creator_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), creator,
        GetArena());
    // @@protoc_insertion_point(field_set_allocated:common.SignatureHeader.creator)
  }
  inline std::string* SignatureHeader::unsafe_arena_release_creator() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.SignatureHeader.creator)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return creator_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void SignatureHeader::unsafe_arena_set_allocated_creator(
      std::string* creator) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (creator != nullptr) {
      
    } else {
      
    }
    creator_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        creator, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.SignatureHeader.creator)
  }
  
  // bytes nonce = 2;
  inline void SignatureHeader::clear_nonce() {
    nonce_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& SignatureHeader::nonce() const {
    // @@protoc_insertion_point(field_get:common.SignatureHeader.nonce)
    return _internal_nonce();
  }
  inline void SignatureHeader::set_nonce(const std::string& value) {
    _internal_set_nonce(value);
    // @@protoc_insertion_point(field_set:common.SignatureHeader.nonce)
  }
  inline std::string* SignatureHeader::mutable_nonce() {
    // @@protoc_insertion_point(field_mutable:common.SignatureHeader.nonce)
    return _internal_mutable_nonce();
  }
  inline const std::string& SignatureHeader::_internal_nonce() const {
    return nonce_.Get();
  }
  inline void SignatureHeader::_internal_set_nonce(const std::string& value) {
    
    nonce_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void SignatureHeader::set_nonce(std::string&& value) {
    
    nonce_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.SignatureHeader.nonce)
  }
  inline void SignatureHeader::set_nonce(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    nonce_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.SignatureHeader.nonce)
  }
  inline void SignatureHeader::set_nonce(const void* value,
      size_t size) {
    
    nonce_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.SignatureHeader.nonce)
  }
  inline std::string* SignatureHeader::_internal_mutable_nonce() {
    
    return nonce_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* SignatureHeader::release_nonce() {
    // @@protoc_insertion_point(field_release:common.SignatureHeader.nonce)
    return nonce_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void SignatureHeader::set_allocated_nonce(std::string* nonce) {
    if (nonce != nullptr) {
      
    } else {
      
    }
    nonce_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), nonce,
        GetArena());
    // @@protoc_insertion_point(field_set_allocated:common.SignatureHeader.nonce)
  }
  inline std::string* SignatureHeader::unsafe_arena_release_nonce() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.SignatureHeader.nonce)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return nonce_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void SignatureHeader::unsafe_arena_set_allocated_nonce(
      std::string* nonce) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (nonce != nullptr) {
      
    } else {
      
    }
    nonce_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        nonce, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.SignatureHeader.nonce)
  }
  
  // -------------------------------------------------------------------
  
  // Payload
  
  // .common.Header header = 1;
  inline bool Payload::_internal_has_header() const {
    return this != internal_default_instance() && header_ != nullptr;
  }
  inline bool Payload::has_header() const {
    return _internal_has_header();
  }
  inline void Payload::clear_header() {
    if (GetArena() == nullptr && header_ != nullptr) {
      delete header_;
    }
    header_ = nullptr;
  }
  inline const ::common::Header& Payload::_internal_header() const {
    const ::common::Header* p = header_;
    return p != nullptr ? *p : *reinterpret_cast<const ::common::Header*>(
        &::common::_Header_default_instance_);
  }
  inline const ::common::Header& Payload::header() const {
    // @@protoc_insertion_point(field_get:common.Payload.header)
    return _internal_header();
  }
  inline void Payload::unsafe_arena_set_allocated_header(
      ::common::Header* header) {
    if (GetArena() == nullptr) {
      delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(header_);
    }
    header_ = header;
    if (header) {
      
    } else {
      
    }
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.Payload.header)
  }
  inline ::common::Header* Payload::release_header() {
    auto temp = unsafe_arena_release_header();
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    return temp;
  }
  inline ::common::Header* Payload::unsafe_arena_release_header() {
    // @@protoc_insertion_point(field_release:common.Payload.header)
    
    ::common::Header* temp = header_;
    header_ = nullptr;
    return temp;
  }
  inline ::common::Header* Payload::_internal_mutable_header() {
    
    if (header_ == nullptr) {
      auto* p = CreateMaybeMessage<::common::Header>(GetArena());
      header_ = p;
    }
    return header_;
  }
  inline ::common::Header* Payload::mutable_header() {
    // @@protoc_insertion_point(field_mutable:common.Payload.header)
    return _internal_mutable_header();
  }
  inline void Payload::set_allocated_header(::common::Header* header) {
    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
    if (message_arena == nullptr) {
      delete header_;
    }
    if (header) {
      ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(header);
      if (message_arena != submessage_arena) {
        header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
            message_arena, header, submessage_arena);
      }
      
    } else {
      
    }
    header_ = header;
    // @@protoc_insertion_point(field_set_allocated:common.Payload.header)
  }
  
  // bytes data = 2;
  inline void Payload::clear_data() {
    data_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& Payload::data() const {
    // @@protoc_insertion_point(field_get:common.Payload.data)
    return _internal_data();
  }
  inline void Payload::set_data(const std::string& value) {
    _internal_set_data(value);
    // @@protoc_insertion_point(field_set:common.Payload.data)
  }
  inline std::string* Payload::mutable_data() {
    // @@protoc_insertion_point(field_mutable:common.Payload.data)
    return _internal_mutable_data();
  }
  inline const std::string& Payload::_internal_data() const {
    return data_.Get();
  }
  inline void Payload::_internal_set_data(const std::string& value) {
    
    data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void Payload::set_data(std::string&& value) {
    
    data_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.Payload.data)
  }
  inline void Payload::set_data(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.Payload.data)
  }
  inline void Payload::set_data(const void* value,
      size_t size) {
    
    data_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.Payload.data)
  }
  inline std::string* Payload::_internal_mutable_data() {
    
    return data_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* Payload::release_data() {
    // @@protoc_insertion_point(field_release:common.Payload.data)
    return data_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void Payload::set_allocated_data(std::string* data) {
    if (data != nullptr) {
      
    } else {
      
    }
    data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data,
        GetArena());
    // @@protoc_insertion_point(field_set_allocated:common.Payload.data)
  }
  inline std::string* Payload::unsafe_arena_release_data() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.Payload.data)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return data_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void Payload::unsafe_arena_set_allocated_data(
      std::string* data) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (data != nullptr) {
      
    } else {
      
    }
    data_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        data, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.Payload.data)
  }
  
  // -------------------------------------------------------------------
  
  // Envelope
  
  // bytes payload = 1;
  inline void Envelope::clear_payload() {
    payload_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& Envelope::payload() const {
    // @@protoc_insertion_point(field_get:common.Envelope.payload)
    return _internal_payload();
  }
  inline void Envelope::set_payload(const std::string& value) {
    _internal_set_payload(value);
    // @@protoc_insertion_point(field_set:common.Envelope.payload)
  }
  inline std::string* Envelope::mutable_payload() {
    // @@protoc_insertion_point(field_mutable:common.Envelope.payload)
    return _internal_mutable_payload();
  }
  inline const std::string& Envelope::_internal_payload() const {
    return payload_.Get();
  }
  inline void Envelope::_internal_set_payload(const std::string& value) {
    
    payload_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void Envelope::set_payload(std::string&& value) {
    
    payload_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.Envelope.payload)
  }
  inline void Envelope::set_payload(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    payload_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.Envelope.payload)
  }
  inline void Envelope::set_payload(const void* value,
      size_t size) {
    
    payload_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.Envelope.payload)
  }
  inline std::string* Envelope::_internal_mutable_payload() {
    
    return payload_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* Envelope::release_payload() {
    // @@protoc_insertion_point(field_release:common.Envelope.payload)
    return payload_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void Envelope::set_allocated_payload(std::string* payload) {
    if (payload != nullptr) {
      
    } else {
      
    }
    payload_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), payload,
        GetArena());
    // @@protoc_insertion_point(field_set_allocated:common.Envelope.payload)
  }
  inline std::string* Envelope::unsafe_arena_release_payload() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.Envelope.payload)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return payload_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void Envelope::unsafe_arena_set_allocated_payload(
      std::string* payload) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (payload != nullptr) {
      
    } else {
      
    }
    payload_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        payload, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.Envelope.payload)
  }
  
  // bytes signature = 2;
  inline void Envelope::clear_signature() {
    signature_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& Envelope::signature() const {
    // @@protoc_insertion_point(field_get:common.Envelope.signature)
    return _internal_signature();
  }
  inline void Envelope::set_signature(const std::string& value) {
    _internal_set_signature(value);
    // @@protoc_insertion_point(field_set:common.Envelope.signature)
  }
  inline std::string* Envelope::mutable_signature() {
    // @@protoc_insertion_point(field_mutable:common.Envelope.signature)
    return _internal_mutable_signature();
  }
  inline const std::string& Envelope::_internal_signature() const {
    return signature_.Get();
  }
  inline void Envelope::_internal_set_signature(const std::string& value) {
    
    signature_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void Envelope::set_signature(std::string&& value) {
    
    signature_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.Envelope.signature)
  }
  inline void Envelope::set_signature(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    signature_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.Envelope.signature)
  }
  inline void Envelope::set_signature(const void* value,
      size_t size) {
    
    signature_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.Envelope.signature)
  }
  inline std::string* Envelope::_internal_mutable_signature() {
    
    return signature_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* Envelope::release_signature() {
    // @@protoc_insertion_point(field_release:common.Envelope.signature)
    return signature_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void Envelope::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:common.Envelope.signature)
  }
  inline std::string* Envelope::unsafe_arena_release_signature() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.Envelope.signature)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return signature_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void Envelope::unsafe_arena_set_allocated_signature(
      std::string* signature) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (signature != nullptr) {
      
    } else {
      
    }
    signature_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        signature, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.Envelope.signature)
  }
  
  // -------------------------------------------------------------------
  
  // Block
  
  // .common.BlockHeader header = 1;
  inline bool Block::_internal_has_header() const {
    return this != internal_default_instance() && header_ != nullptr;
  }
  inline bool Block::has_header() const {
    return _internal_has_header();
  }
  inline void Block::clear_header() {
    if (GetArena() == nullptr && header_ != nullptr) {
      delete header_;
    }
    header_ = nullptr;
  }
  inline const ::common::BlockHeader& Block::_internal_header() const {
    const ::common::BlockHeader* p = header_;
    return p != nullptr ? *p : *reinterpret_cast<const ::common::BlockHeader*>(
        &::common::_BlockHeader_default_instance_);
  }
  inline const ::common::BlockHeader& Block::header() const {
    // @@protoc_insertion_point(field_get:common.Block.header)
    return _internal_header();
  }
  inline void Block::unsafe_arena_set_allocated_header(
      ::common::BlockHeader* header) {
    if (GetArena() == nullptr) {
      delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(header_);
    }
    header_ = header;
    if (header) {
      
    } else {
      
    }
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.Block.header)
  }
  inline ::common::BlockHeader* Block::release_header() {
    auto temp = unsafe_arena_release_header();
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    return temp;
  }
  inline ::common::BlockHeader* Block::unsafe_arena_release_header() {
    // @@protoc_insertion_point(field_release:common.Block.header)
    
    ::common::BlockHeader* temp = header_;
    header_ = nullptr;
    return temp;
  }
  inline ::common::BlockHeader* Block::_internal_mutable_header() {
    
    if (header_ == nullptr) {
      auto* p = CreateMaybeMessage<::common::BlockHeader>(GetArena());
      header_ = p;
    }
    return header_;
  }
  inline ::common::BlockHeader* Block::mutable_header() {
    // @@protoc_insertion_point(field_mutable:common.Block.header)
    return _internal_mutable_header();
  }
  inline void Block::set_allocated_header(::common::BlockHeader* header) {
    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
    if (message_arena == nullptr) {
      delete header_;
    }
    if (header) {
      ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(header);
      if (message_arena != submessage_arena) {
        header = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
            message_arena, header, submessage_arena);
      }
      
    } else {
      
    }
    header_ = header;
    // @@protoc_insertion_point(field_set_allocated:common.Block.header)
  }
  
  // .common.BlockData data = 2;
  inline bool Block::_internal_has_data() const {
    return this != internal_default_instance() && data_ != nullptr;
  }
  inline bool Block::has_data() const {
    return _internal_has_data();
  }
  inline void Block::clear_data() {
    if (GetArena() == nullptr && data_ != nullptr) {
      delete data_;
    }
    data_ = nullptr;
  }
  inline const ::common::BlockData& Block::_internal_data() const {
    const ::common::BlockData* p = data_;
    return p != nullptr ? *p : *reinterpret_cast<const ::common::BlockData*>(
        &::common::_BlockData_default_instance_);
  }
  inline const ::common::BlockData& Block::data() const {
    // @@protoc_insertion_point(field_get:common.Block.data)
    return _internal_data();
  }
  inline void Block::unsafe_arena_set_allocated_data(
      ::common::BlockData* data) {
    if (GetArena() == nullptr) {
      delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(data_);
    }
    data_ = data;
    if (data) {
      
    } else {
      
    }
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.Block.data)
  }
  inline ::common::BlockData* Block::release_data() {
    auto temp = unsafe_arena_release_data();
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    return temp;
  }
  inline ::common::BlockData* Block::unsafe_arena_release_data() {
    // @@protoc_insertion_point(field_release:common.Block.data)
    
    ::common::BlockData* temp = data_;
    data_ = nullptr;
    return temp;
  }
  inline ::common::BlockData* Block::_internal_mutable_data() {
    
    if (data_ == nullptr) {
      auto* p = CreateMaybeMessage<::common::BlockData>(GetArena());
      data_ = p;
    }
    return data_;
  }
  inline ::common::BlockData* Block::mutable_data() {
    // @@protoc_insertion_point(field_mutable:common.Block.data)
    return _internal_mutable_data();
  }
  inline void Block::set_allocated_data(::common::BlockData* data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
    if (message_arena == nullptr) {
      delete data_;
    }
    if (data) {
      ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(data);
      if (message_arena != submessage_arena) {
        data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
            message_arena, data, submessage_arena);
      }
      
    } else {
      
    }
    data_ = data;
    // @@protoc_insertion_point(field_set_allocated:common.Block.data)
  }
  
  // .common.BlockMetadata metadata = 3;
  inline bool Block::_internal_has_metadata() const {
    return this != internal_default_instance() && metadata_ != nullptr;
  }
  inline bool Block::has_metadata() const {
    return _internal_has_metadata();
  }
  inline void Block::clear_metadata() {
    if (GetArena() == nullptr && metadata_ != nullptr) {
      delete metadata_;
    }
    metadata_ = nullptr;
  }
  inline const ::common::BlockMetadata& Block::_internal_metadata() const {
    const ::common::BlockMetadata* p = metadata_;
    return p != nullptr ? *p : *reinterpret_cast<const ::common::BlockMetadata*>(
        &::common::_BlockMetadata_default_instance_);
  }
  inline const ::common::BlockMetadata& Block::metadata() const {
    // @@protoc_insertion_point(field_get:common.Block.metadata)
    return _internal_metadata();
  }
  inline void Block::unsafe_arena_set_allocated_metadata(
      ::common::BlockMetadata* metadata) {
    if (GetArena() == nullptr) {
      delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(metadata_);
    }
    metadata_ = metadata;
    if (metadata) {
      
    } else {
      
    }
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.Block.metadata)
  }
  inline ::common::BlockMetadata* Block::release_metadata() {
    auto temp = unsafe_arena_release_metadata();
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    return temp;
  }
  inline ::common::BlockMetadata* Block::unsafe_arena_release_metadata() {
    // @@protoc_insertion_point(field_release:common.Block.metadata)
    
    ::common::BlockMetadata* temp = metadata_;
    metadata_ = nullptr;
    return temp;
  }
  inline ::common::BlockMetadata* Block::_internal_mutable_metadata() {
    
    if (metadata_ == nullptr) {
      auto* p = CreateMaybeMessage<::common::BlockMetadata>(GetArena());
      metadata_ = p;
    }
    return metadata_;
  }
  inline ::common::BlockMetadata* Block::mutable_metadata() {
    // @@protoc_insertion_point(field_mutable:common.Block.metadata)
    return _internal_mutable_metadata();
  }
  inline void Block::set_allocated_metadata(::common::BlockMetadata* metadata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
    if (message_arena == nullptr) {
      delete metadata_;
    }
    if (metadata) {
      ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(metadata);
      if (message_arena != submessage_arena) {
        metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
            message_arena, metadata, submessage_arena);
      }
      
    } else {
      
    }
    metadata_ = metadata;
    // @@protoc_insertion_point(field_set_allocated:common.Block.metadata)
  }
  
  // -------------------------------------------------------------------
  
  // BlockHeader
  
  // uint64 number = 1;
  inline void BlockHeader::clear_number() {
    number_ = PROTOBUF_ULONGLONG(0);
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 BlockHeader::_internal_number() const {
    return number_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 BlockHeader::number() const {
    // @@protoc_insertion_point(field_get:common.BlockHeader.number)
    return _internal_number();
  }
  inline void BlockHeader::_internal_set_number(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    
    number_ = value;
  }
  inline void BlockHeader::set_number(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    _internal_set_number(value);
    // @@protoc_insertion_point(field_set:common.BlockHeader.number)
  }
  
  // bytes previous_hash = 2;
  inline void BlockHeader::clear_previous_hash() {
    previous_hash_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& BlockHeader::previous_hash() const {
    // @@protoc_insertion_point(field_get:common.BlockHeader.previous_hash)
    return _internal_previous_hash();
  }
  inline void BlockHeader::set_previous_hash(const std::string& value) {
    _internal_set_previous_hash(value);
    // @@protoc_insertion_point(field_set:common.BlockHeader.previous_hash)
  }
  inline std::string* BlockHeader::mutable_previous_hash() {
    // @@protoc_insertion_point(field_mutable:common.BlockHeader.previous_hash)
    return _internal_mutable_previous_hash();
  }
  inline const std::string& BlockHeader::_internal_previous_hash() const {
    return previous_hash_.Get();
  }
  inline void BlockHeader::_internal_set_previous_hash(const std::string& value) {
    
    previous_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void BlockHeader::set_previous_hash(std::string&& value) {
    
    previous_hash_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.BlockHeader.previous_hash)
  }
  inline void BlockHeader::set_previous_hash(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    previous_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.BlockHeader.previous_hash)
  }
  inline void BlockHeader::set_previous_hash(const void* value,
      size_t size) {
    
    previous_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.BlockHeader.previous_hash)
  }
  inline std::string* BlockHeader::_internal_mutable_previous_hash() {
    
    return previous_hash_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* BlockHeader::release_previous_hash() {
    // @@protoc_insertion_point(field_release:common.BlockHeader.previous_hash)
    return previous_hash_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void BlockHeader::set_allocated_previous_hash(std::string* previous_hash) {
    if (previous_hash != nullptr) {
      
    } else {
      
    }
    previous_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), previous_hash,
        GetArena());
    // @@protoc_insertion_point(field_set_allocated:common.BlockHeader.previous_hash)
  }
  inline std::string* BlockHeader::unsafe_arena_release_previous_hash() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.BlockHeader.previous_hash)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return previous_hash_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void BlockHeader::unsafe_arena_set_allocated_previous_hash(
      std::string* previous_hash) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (previous_hash != nullptr) {
      
    } else {
      
    }
    previous_hash_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        previous_hash, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.BlockHeader.previous_hash)
  }
  
  // bytes data_hash = 3;
  inline void BlockHeader::clear_data_hash() {
    data_hash_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& BlockHeader::data_hash() const {
    // @@protoc_insertion_point(field_get:common.BlockHeader.data_hash)
    return _internal_data_hash();
  }
  inline void BlockHeader::set_data_hash(const std::string& value) {
    _internal_set_data_hash(value);
    // @@protoc_insertion_point(field_set:common.BlockHeader.data_hash)
  }
  inline std::string* BlockHeader::mutable_data_hash() {
    // @@protoc_insertion_point(field_mutable:common.BlockHeader.data_hash)
    return _internal_mutable_data_hash();
  }
  inline const std::string& BlockHeader::_internal_data_hash() const {
    return data_hash_.Get();
  }
  inline void BlockHeader::_internal_set_data_hash(const std::string& value) {
    
    data_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void BlockHeader::set_data_hash(std::string&& value) {
    
    data_hash_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.BlockHeader.data_hash)
  }
  inline void BlockHeader::set_data_hash(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    data_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.BlockHeader.data_hash)
  }
  inline void BlockHeader::set_data_hash(const void* value,
      size_t size) {
    
    data_hash_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.BlockHeader.data_hash)
  }
  inline std::string* BlockHeader::_internal_mutable_data_hash() {
    
    return data_hash_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* BlockHeader::release_data_hash() {
    // @@protoc_insertion_point(field_release:common.BlockHeader.data_hash)
    return data_hash_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void BlockHeader::set_allocated_data_hash(std::string* data_hash) {
    if (data_hash != nullptr) {
      
    } else {
      
    }
    data_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), data_hash,
        GetArena());
    // @@protoc_insertion_point(field_set_allocated:common.BlockHeader.data_hash)
  }
  inline std::string* BlockHeader::unsafe_arena_release_data_hash() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.BlockHeader.data_hash)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return data_hash_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void BlockHeader::unsafe_arena_set_allocated_data_hash(
      std::string* data_hash) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (data_hash != nullptr) {
      
    } else {
      
    }
    data_hash_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        data_hash, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.BlockHeader.data_hash)
  }
  
  // -------------------------------------------------------------------
  
  // BlockData
  
  // repeated bytes data = 1;
  inline int BlockData::_internal_data_size() const {
    return data_.size();
  }
  inline int BlockData::data_size() const {
    return _internal_data_size();
  }
  inline void BlockData::clear_data() {
    data_.Clear();
  }
  inline std::string* BlockData::add_data() {
    // @@protoc_insertion_point(field_add_mutable:common.BlockData.data)
    return _internal_add_data();
  }
  inline const std::string& BlockData::_internal_data(int index) const {
    return data_.Get(index);
  }
  inline const std::string& BlockData::data(int index) const {
    // @@protoc_insertion_point(field_get:common.BlockData.data)
    return _internal_data(index);
  }
  inline std::string* BlockData::mutable_data(int index) {
    // @@protoc_insertion_point(field_mutable:common.BlockData.data)
    return data_.Mutable(index);
  }
  inline void BlockData::set_data(int index, const std::string& value) {
    // @@protoc_insertion_point(field_set:common.BlockData.data)
    data_.Mutable(index)->assign(value);
  }
  inline void BlockData::set_data(int index, std::string&& value) {
    // @@protoc_insertion_point(field_set:common.BlockData.data)
    data_.Mutable(index)->assign(std::move(value));
  }
  inline void BlockData::set_data(int index, const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    data_.Mutable(index)->assign(value);
    // @@protoc_insertion_point(field_set_char:common.BlockData.data)
  }
  inline void BlockData::set_data(int index, const void* value, size_t size) {
    data_.Mutable(index)->assign(
      reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_set_pointer:common.BlockData.data)
  }
  inline std::string* BlockData::_internal_add_data() {
    return data_.Add();
  }
  inline void BlockData::add_data(const std::string& value) {
    data_.Add()->assign(value);
    // @@protoc_insertion_point(field_add:common.BlockData.data)
  }
  inline void BlockData::add_data(std::string&& value) {
    data_.Add(std::move(value));
    // @@protoc_insertion_point(field_add:common.BlockData.data)
  }
  inline void BlockData::add_data(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    data_.Add()->assign(value);
    // @@protoc_insertion_point(field_add_char:common.BlockData.data)
  }
  inline void BlockData::add_data(const void* value, size_t size) {
    data_.Add()->assign(reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_add_pointer:common.BlockData.data)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
  BlockData::data() const {
    // @@protoc_insertion_point(field_list:common.BlockData.data)
    return data_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
  BlockData::mutable_data() {
    // @@protoc_insertion_point(field_mutable_list:common.BlockData.data)
    return &data_;
  }
  
  // -------------------------------------------------------------------
  
  // BlockMetadata
  
  // repeated bytes metadata = 1;
  inline int BlockMetadata::_internal_metadata_size() const {
    return metadata_.size();
  }
  inline int BlockMetadata::metadata_size() const {
    return _internal_metadata_size();
  }
  inline void BlockMetadata::clear_metadata() {
    metadata_.Clear();
  }
  inline std::string* BlockMetadata::add_metadata() {
    // @@protoc_insertion_point(field_add_mutable:common.BlockMetadata.metadata)
    return _internal_add_metadata();
  }
  inline const std::string& BlockMetadata::_internal_metadata(int index) const {
    return metadata_.Get(index);
  }
  inline const std::string& BlockMetadata::metadata(int index) const {
    // @@protoc_insertion_point(field_get:common.BlockMetadata.metadata)
    return _internal_metadata(index);
  }
  inline std::string* BlockMetadata::mutable_metadata(int index) {
    // @@protoc_insertion_point(field_mutable:common.BlockMetadata.metadata)
    return metadata_.Mutable(index);
  }
  inline void BlockMetadata::set_metadata(int index, const std::string& value) {
    // @@protoc_insertion_point(field_set:common.BlockMetadata.metadata)
    metadata_.Mutable(index)->assign(value);
  }
  inline void BlockMetadata::set_metadata(int index, std::string&& value) {
    // @@protoc_insertion_point(field_set:common.BlockMetadata.metadata)
    metadata_.Mutable(index)->assign(std::move(value));
  }
  inline void BlockMetadata::set_metadata(int index, const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    metadata_.Mutable(index)->assign(value);
    // @@protoc_insertion_point(field_set_char:common.BlockMetadata.metadata)
  }
  inline void BlockMetadata::set_metadata(int index, const void* value, size_t size) {
    metadata_.Mutable(index)->assign(
      reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_set_pointer:common.BlockMetadata.metadata)
  }
  inline std::string* BlockMetadata::_internal_add_metadata() {
    return metadata_.Add();
  }
  inline void BlockMetadata::add_metadata(const std::string& value) {
    metadata_.Add()->assign(value);
    // @@protoc_insertion_point(field_add:common.BlockMetadata.metadata)
  }
  inline void BlockMetadata::add_metadata(std::string&& value) {
    metadata_.Add(std::move(value));
    // @@protoc_insertion_point(field_add:common.BlockMetadata.metadata)
  }
  inline void BlockMetadata::add_metadata(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    metadata_.Add()->assign(value);
    // @@protoc_insertion_point(field_add_char:common.BlockMetadata.metadata)
  }
  inline void BlockMetadata::add_metadata(const void* value, size_t size) {
    metadata_.Add()->assign(reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_add_pointer:common.BlockMetadata.metadata)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
  BlockMetadata::metadata() const {
    // @@protoc_insertion_point(field_list:common.BlockMetadata.metadata)
    return metadata_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
  BlockMetadata::mutable_metadata() {
    // @@protoc_insertion_point(field_mutable_list:common.BlockMetadata.metadata)
    return &metadata_;
  }
  
  // -------------------------------------------------------------------
  
  // OrdererBlockMetadata
  
  // .common.LastConfig last_config = 1;
  inline bool OrdererBlockMetadata::_internal_has_last_config() const {
    return this != internal_default_instance() && last_config_ != nullptr;
  }
  inline bool OrdererBlockMetadata::has_last_config() const {
    return _internal_has_last_config();
  }
  inline void OrdererBlockMetadata::clear_last_config() {
    if (GetArena() == nullptr && last_config_ != nullptr) {
      delete last_config_;
    }
    last_config_ = nullptr;
  }
  inline const ::common::LastConfig& OrdererBlockMetadata::_internal_last_config() const {
    const ::common::LastConfig* p = last_config_;
    return p != nullptr ? *p : *reinterpret_cast<const ::common::LastConfig*>(
        &::common::_LastConfig_default_instance_);
  }
  inline const ::common::LastConfig& OrdererBlockMetadata::last_config() const {
    // @@protoc_insertion_point(field_get:common.OrdererBlockMetadata.last_config)
    return _internal_last_config();
  }
  inline void OrdererBlockMetadata::unsafe_arena_set_allocated_last_config(
      ::common::LastConfig* last_config) {
    if (GetArena() == nullptr) {
      delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(last_config_);
    }
    last_config_ = last_config;
    if (last_config) {
      
    } else {
      
    }
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.OrdererBlockMetadata.last_config)
  }
  inline ::common::LastConfig* OrdererBlockMetadata::release_last_config() {
    auto temp = unsafe_arena_release_last_config();
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    return temp;
  }
  inline ::common::LastConfig* OrdererBlockMetadata::unsafe_arena_release_last_config() {
    // @@protoc_insertion_point(field_release:common.OrdererBlockMetadata.last_config)
    
    ::common::LastConfig* temp = last_config_;
    last_config_ = nullptr;
    return temp;
  }
  inline ::common::LastConfig* OrdererBlockMetadata::_internal_mutable_last_config() {
    
    if (last_config_ == nullptr) {
      auto* p = CreateMaybeMessage<::common::LastConfig>(GetArena());
      last_config_ = p;
    }
    return last_config_;
  }
  inline ::common::LastConfig* OrdererBlockMetadata::mutable_last_config() {
    // @@protoc_insertion_point(field_mutable:common.OrdererBlockMetadata.last_config)
    return _internal_mutable_last_config();
  }
  inline void OrdererBlockMetadata::set_allocated_last_config(::common::LastConfig* last_config) {
    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena();
    if (message_arena == nullptr) {
      delete last_config_;
    }
    if (last_config) {
      ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(last_config);
      if (message_arena != submessage_arena) {
        last_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
            message_arena, last_config, submessage_arena);
      }
      
    } else {
      
    }
    last_config_ = last_config;
    // @@protoc_insertion_point(field_set_allocated:common.OrdererBlockMetadata.last_config)
  }
  
  // bytes consenter_metadata = 2;
  inline void OrdererBlockMetadata::clear_consenter_metadata() {
    consenter_metadata_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline const std::string& OrdererBlockMetadata::consenter_metadata() const {
    // @@protoc_insertion_point(field_get:common.OrdererBlockMetadata.consenter_metadata)
    return _internal_consenter_metadata();
  }
  inline void OrdererBlockMetadata::set_consenter_metadata(const std::string& value) {
    _internal_set_consenter_metadata(value);
    // @@protoc_insertion_point(field_set:common.OrdererBlockMetadata.consenter_metadata)
  }
  inline std::string* OrdererBlockMetadata::mutable_consenter_metadata() {
    // @@protoc_insertion_point(field_mutable:common.OrdererBlockMetadata.consenter_metadata)
    return _internal_mutable_consenter_metadata();
  }
  inline const std::string& OrdererBlockMetadata::_internal_consenter_metadata() const {
    return consenter_metadata_.Get();
  }
  inline void OrdererBlockMetadata::_internal_set_consenter_metadata(const std::string& value) {
    
    consenter_metadata_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
  }
  inline void OrdererBlockMetadata::set_consenter_metadata(std::string&& value) {
    
    consenter_metadata_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
    // @@protoc_insertion_point(field_set_rvalue:common.OrdererBlockMetadata.consenter_metadata)
  }
  inline void OrdererBlockMetadata::set_consenter_metadata(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    
    consenter_metadata_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
                GetArena());
    // @@protoc_insertion_point(field_set_char:common.OrdererBlockMetadata.consenter_metadata)
  }
  inline void OrdererBlockMetadata::set_consenter_metadata(const void* value,
      size_t size) {
    
    consenter_metadata_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
        reinterpret_cast<const char*>(value), size), GetArena());
    // @@protoc_insertion_point(field_set_pointer:common.OrdererBlockMetadata.consenter_metadata)
  }
  inline std::string* OrdererBlockMetadata::_internal_mutable_consenter_metadata() {
    
    return consenter_metadata_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline std::string* OrdererBlockMetadata::release_consenter_metadata() {
    // @@protoc_insertion_point(field_release:common.OrdererBlockMetadata.consenter_metadata)
    return consenter_metadata_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  }
  inline void OrdererBlockMetadata::set_allocated_consenter_metadata(std::string* consenter_metadata) {
    if (consenter_metadata != nullptr) {
      
    } else {
      
    }
    consenter_metadata_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), consenter_metadata,
        GetArena());
    // @@protoc_insertion_point(field_set_allocated:common.OrdererBlockMetadata.consenter_metadata)
  }
  inline std::string* OrdererBlockMetadata::unsafe_arena_release_consenter_metadata() {
    // @@protoc_insertion_point(field_unsafe_arena_release:common.OrdererBlockMetadata.consenter_metadata)
    GOOGLE_DCHECK(GetArena() != nullptr);
    
    return consenter_metadata_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        GetArena());
  }
  inline void OrdererBlockMetadata::unsafe_arena_set_allocated_consenter_metadata(
      std::string* consenter_metadata) {
    GOOGLE_DCHECK(GetArena() != nullptr);
    if (consenter_metadata != nullptr) {
      
    } else {
      
    }
    consenter_metadata_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
        consenter_metadata, GetArena());
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:common.OrdererBlockMetadata.consenter_metadata)
  }
  
  #ifdef __GNUC__
    #pragma GCC diagnostic pop
  #endif  // __GNUC__
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  
  // @@protoc_insertion_point(namespace_scope)
  
  }  // namespace common
  
  PROTOBUF_NAMESPACE_OPEN
  
  template <> struct is_proto_enum< ::common::Status> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::common::Status>() {
    return ::common::Status_descriptor();
  }
  template <> struct is_proto_enum< ::common::HeaderType> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::common::HeaderType>() {
    return ::common::HeaderType_descriptor();
  }
  template <> struct is_proto_enum< ::common::BlockMetadataIndex> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::common::BlockMetadataIndex>() {
    return ::common::BlockMetadataIndex_descriptor();
  }
  
  PROTOBUF_NAMESPACE_CLOSE
  
  // @@protoc_insertion_point(global_scope)
  
  #include <google/protobuf/port_undef.inc>
  #endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_common_2fcommon_2eproto
  