github.com/cockroachdb/cockroach@v20.2.0-alpha.1+incompatible/c-deps/libroach/protos/roachpb/errors.pb.h

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

#ifndef PROTOBUF_INCLUDED_roachpb_2ferrors_2eproto
#define PROTOBUF_INCLUDED_roachpb_2ferrors_2eproto

#include <string>

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

#if GOOGLE_PROTOBUF_VERSION < 3006000
#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 3006000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/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/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_util.h>
#include "roachpb/data.pb.h"
#include "roachpb/metadata.pb.h"
#include "util/hlc/timestamp.pb.h"
// @@protoc_insertion_point(includes)
#define PROTOBUF_INTERNAL_EXPORT_protobuf_roachpb_2ferrors_2eproto 

namespace protobuf_roachpb_2ferrors_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[33];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static const ::google::protobuf::uint32 offsets[];
};
}  // namespace protobuf_roachpb_2ferrors_2eproto
namespace cockroach {
namespace roachpb {
class AmbiguousResultError;
class AmbiguousResultErrorDefaultTypeInternal;
extern AmbiguousResultErrorDefaultTypeInternal _AmbiguousResultError_default_instance_;
class BatchTimestampBeforeGCError;
class BatchTimestampBeforeGCErrorDefaultTypeInternal;
extern BatchTimestampBeforeGCErrorDefaultTypeInternal _BatchTimestampBeforeGCError_default_instance_;
class ConditionFailedError;
class ConditionFailedErrorDefaultTypeInternal;
extern ConditionFailedErrorDefaultTypeInternal _ConditionFailedError_default_instance_;
class ErrPosition;
class ErrPositionDefaultTypeInternal;
extern ErrPositionDefaultTypeInternal _ErrPosition_default_instance_;
class Error;
class ErrorDefaultTypeInternal;
extern ErrorDefaultTypeInternal _Error_default_instance_;
class ErrorDetail;
class ErrorDetailDefaultTypeInternal;
extern ErrorDetailDefaultTypeInternal _ErrorDetail_default_instance_;
class IndeterminateCommitError;
class IndeterminateCommitErrorDefaultTypeInternal;
extern IndeterminateCommitErrorDefaultTypeInternal _IndeterminateCommitError_default_instance_;
class IntegerOverflowError;
class IntegerOverflowErrorDefaultTypeInternal;
extern IntegerOverflowErrorDefaultTypeInternal _IntegerOverflowError_default_instance_;
class IntentMissingError;
class IntentMissingErrorDefaultTypeInternal;
extern IntentMissingErrorDefaultTypeInternal _IntentMissingError_default_instance_;
class LeaseRejectedError;
class LeaseRejectedErrorDefaultTypeInternal;
extern LeaseRejectedErrorDefaultTypeInternal _LeaseRejectedError_default_instance_;
class MergeInProgressError;
class MergeInProgressErrorDefaultTypeInternal;
extern MergeInProgressErrorDefaultTypeInternal _MergeInProgressError_default_instance_;
class NodeUnavailableError;
class NodeUnavailableErrorDefaultTypeInternal;
extern NodeUnavailableErrorDefaultTypeInternal _NodeUnavailableError_default_instance_;
class NotLeaseHolderError;
class NotLeaseHolderErrorDefaultTypeInternal;
extern NotLeaseHolderErrorDefaultTypeInternal _NotLeaseHolderError_default_instance_;
class OpRequiresTxnError;
class OpRequiresTxnErrorDefaultTypeInternal;
extern OpRequiresTxnErrorDefaultTypeInternal _OpRequiresTxnError_default_instance_;
class RaftGroupDeletedError;
class RaftGroupDeletedErrorDefaultTypeInternal;
extern RaftGroupDeletedErrorDefaultTypeInternal _RaftGroupDeletedError_default_instance_;
class RangeFeedRetryError;
class RangeFeedRetryErrorDefaultTypeInternal;
extern RangeFeedRetryErrorDefaultTypeInternal _RangeFeedRetryError_default_instance_;
class RangeKeyMismatchError;
class RangeKeyMismatchErrorDefaultTypeInternal;
extern RangeKeyMismatchErrorDefaultTypeInternal _RangeKeyMismatchError_default_instance_;
class RangeNotFoundError;
class RangeNotFoundErrorDefaultTypeInternal;
extern RangeNotFoundErrorDefaultTypeInternal _RangeNotFoundError_default_instance_;
class ReadWithinUncertaintyIntervalError;
class ReadWithinUncertaintyIntervalErrorDefaultTypeInternal;
extern ReadWithinUncertaintyIntervalErrorDefaultTypeInternal _ReadWithinUncertaintyIntervalError_default_instance_;
class ReplicaCorruptionError;
class ReplicaCorruptionErrorDefaultTypeInternal;
extern ReplicaCorruptionErrorDefaultTypeInternal _ReplicaCorruptionError_default_instance_;
class ReplicaTooOldError;
class ReplicaTooOldErrorDefaultTypeInternal;
extern ReplicaTooOldErrorDefaultTypeInternal _ReplicaTooOldError_default_instance_;
class SendError;
class SendErrorDefaultTypeInternal;
extern SendErrorDefaultTypeInternal _SendError_default_instance_;
class StoreNotFoundError;
class StoreNotFoundErrorDefaultTypeInternal;
extern StoreNotFoundErrorDefaultTypeInternal _StoreNotFoundError_default_instance_;
class TransactionAbortedError;
class TransactionAbortedErrorDefaultTypeInternal;
extern TransactionAbortedErrorDefaultTypeInternal _TransactionAbortedError_default_instance_;
class TransactionPushError;
class TransactionPushErrorDefaultTypeInternal;
extern TransactionPushErrorDefaultTypeInternal _TransactionPushError_default_instance_;
class TransactionRetryError;
class TransactionRetryErrorDefaultTypeInternal;
extern TransactionRetryErrorDefaultTypeInternal _TransactionRetryError_default_instance_;
class TransactionRetryWithProtoRefreshError;
class TransactionRetryWithProtoRefreshErrorDefaultTypeInternal;
extern TransactionRetryWithProtoRefreshErrorDefaultTypeInternal _TransactionRetryWithProtoRefreshError_default_instance_;
class TransactionStatusError;
class TransactionStatusErrorDefaultTypeInternal;
extern TransactionStatusErrorDefaultTypeInternal _TransactionStatusError_default_instance_;
class TxnAlreadyEncounteredErrorError;
class TxnAlreadyEncounteredErrorErrorDefaultTypeInternal;
extern TxnAlreadyEncounteredErrorErrorDefaultTypeInternal _TxnAlreadyEncounteredErrorError_default_instance_;
class UnhandledRetryableError;
class UnhandledRetryableErrorDefaultTypeInternal;
extern UnhandledRetryableErrorDefaultTypeInternal _UnhandledRetryableError_default_instance_;
class UnsupportedRequestError;
class UnsupportedRequestErrorDefaultTypeInternal;
extern UnsupportedRequestErrorDefaultTypeInternal _UnsupportedRequestError_default_instance_;
class WriteIntentError;
class WriteIntentErrorDefaultTypeInternal;
extern WriteIntentErrorDefaultTypeInternal _WriteIntentError_default_instance_;
class WriteTooOldError;
class WriteTooOldErrorDefaultTypeInternal;
extern WriteTooOldErrorDefaultTypeInternal _WriteTooOldError_default_instance_;
}  // namespace roachpb
}  // namespace cockroach
namespace google {
namespace protobuf {
template<> ::cockroach::roachpb::AmbiguousResultError* Arena::CreateMaybeMessage<::cockroach::roachpb::AmbiguousResultError>(Arena*);
template<> ::cockroach::roachpb::BatchTimestampBeforeGCError* Arena::CreateMaybeMessage<::cockroach::roachpb::BatchTimestampBeforeGCError>(Arena*);
template<> ::cockroach::roachpb::ConditionFailedError* Arena::CreateMaybeMessage<::cockroach::roachpb::ConditionFailedError>(Arena*);
template<> ::cockroach::roachpb::ErrPosition* Arena::CreateMaybeMessage<::cockroach::roachpb::ErrPosition>(Arena*);
template<> ::cockroach::roachpb::Error* Arena::CreateMaybeMessage<::cockroach::roachpb::Error>(Arena*);
template<> ::cockroach::roachpb::ErrorDetail* Arena::CreateMaybeMessage<::cockroach::roachpb::ErrorDetail>(Arena*);
template<> ::cockroach::roachpb::IndeterminateCommitError* Arena::CreateMaybeMessage<::cockroach::roachpb::IndeterminateCommitError>(Arena*);
template<> ::cockroach::roachpb::IntegerOverflowError* Arena::CreateMaybeMessage<::cockroach::roachpb::IntegerOverflowError>(Arena*);
template<> ::cockroach::roachpb::IntentMissingError* Arena::CreateMaybeMessage<::cockroach::roachpb::IntentMissingError>(Arena*);
template<> ::cockroach::roachpb::LeaseRejectedError* Arena::CreateMaybeMessage<::cockroach::roachpb::LeaseRejectedError>(Arena*);
template<> ::cockroach::roachpb::MergeInProgressError* Arena::CreateMaybeMessage<::cockroach::roachpb::MergeInProgressError>(Arena*);
template<> ::cockroach::roachpb::NodeUnavailableError* Arena::CreateMaybeMessage<::cockroach::roachpb::NodeUnavailableError>(Arena*);
template<> ::cockroach::roachpb::NotLeaseHolderError* Arena::CreateMaybeMessage<::cockroach::roachpb::NotLeaseHolderError>(Arena*);
template<> ::cockroach::roachpb::OpRequiresTxnError* Arena::CreateMaybeMessage<::cockroach::roachpb::OpRequiresTxnError>(Arena*);
template<> ::cockroach::roachpb::RaftGroupDeletedError* Arena::CreateMaybeMessage<::cockroach::roachpb::RaftGroupDeletedError>(Arena*);
template<> ::cockroach::roachpb::RangeFeedRetryError* Arena::CreateMaybeMessage<::cockroach::roachpb::RangeFeedRetryError>(Arena*);
template<> ::cockroach::roachpb::RangeKeyMismatchError* Arena::CreateMaybeMessage<::cockroach::roachpb::RangeKeyMismatchError>(Arena*);
template<> ::cockroach::roachpb::RangeNotFoundError* Arena::CreateMaybeMessage<::cockroach::roachpb::RangeNotFoundError>(Arena*);
template<> ::cockroach::roachpb::ReadWithinUncertaintyIntervalError* Arena::CreateMaybeMessage<::cockroach::roachpb::ReadWithinUncertaintyIntervalError>(Arena*);
template<> ::cockroach::roachpb::ReplicaCorruptionError* Arena::CreateMaybeMessage<::cockroach::roachpb::ReplicaCorruptionError>(Arena*);
template<> ::cockroach::roachpb::ReplicaTooOldError* Arena::CreateMaybeMessage<::cockroach::roachpb::ReplicaTooOldError>(Arena*);
template<> ::cockroach::roachpb::SendError* Arena::CreateMaybeMessage<::cockroach::roachpb::SendError>(Arena*);
template<> ::cockroach::roachpb::StoreNotFoundError* Arena::CreateMaybeMessage<::cockroach::roachpb::StoreNotFoundError>(Arena*);
template<> ::cockroach::roachpb::TransactionAbortedError* Arena::CreateMaybeMessage<::cockroach::roachpb::TransactionAbortedError>(Arena*);
template<> ::cockroach::roachpb::TransactionPushError* Arena::CreateMaybeMessage<::cockroach::roachpb::TransactionPushError>(Arena*);
template<> ::cockroach::roachpb::TransactionRetryError* Arena::CreateMaybeMessage<::cockroach::roachpb::TransactionRetryError>(Arena*);
template<> ::cockroach::roachpb::TransactionRetryWithProtoRefreshError* Arena::CreateMaybeMessage<::cockroach::roachpb::TransactionRetryWithProtoRefreshError>(Arena*);
template<> ::cockroach::roachpb::TransactionStatusError* Arena::CreateMaybeMessage<::cockroach::roachpb::TransactionStatusError>(Arena*);
template<> ::cockroach::roachpb::TxnAlreadyEncounteredErrorError* Arena::CreateMaybeMessage<::cockroach::roachpb::TxnAlreadyEncounteredErrorError>(Arena*);
template<> ::cockroach::roachpb::UnhandledRetryableError* Arena::CreateMaybeMessage<::cockroach::roachpb::UnhandledRetryableError>(Arena*);
template<> ::cockroach::roachpb::UnsupportedRequestError* Arena::CreateMaybeMessage<::cockroach::roachpb::UnsupportedRequestError>(Arena*);
template<> ::cockroach::roachpb::WriteIntentError* Arena::CreateMaybeMessage<::cockroach::roachpb::WriteIntentError>(Arena*);
template<> ::cockroach::roachpb::WriteTooOldError* Arena::CreateMaybeMessage<::cockroach::roachpb::WriteTooOldError>(Arena*);
}  // namespace protobuf
}  // namespace google
namespace cockroach {
namespace roachpb {

enum TransactionStatusError_Reason {
  TransactionStatusError_Reason_REASON_UNKNOWN = 0,
  TransactionStatusError_Reason_REASON_TXN_COMMITTED = 2
};
bool TransactionStatusError_Reason_IsValid(int value);
const TransactionStatusError_Reason TransactionStatusError_Reason_Reason_MIN = TransactionStatusError_Reason_REASON_UNKNOWN;
const TransactionStatusError_Reason TransactionStatusError_Reason_Reason_MAX = TransactionStatusError_Reason_REASON_TXN_COMMITTED;
const int TransactionStatusError_Reason_Reason_ARRAYSIZE = TransactionStatusError_Reason_Reason_MAX + 1;

enum RangeFeedRetryError_Reason {
  RangeFeedRetryError_Reason_REASON_REPLICA_REMOVED = 0,
  RangeFeedRetryError_Reason_REASON_RANGE_SPLIT = 1,
  RangeFeedRetryError_Reason_REASON_RANGE_MERGED = 2,
  RangeFeedRetryError_Reason_REASON_RAFT_SNAPSHOT = 3,
  RangeFeedRetryError_Reason_REASON_LOGICAL_OPS_MISSING = 4,
  RangeFeedRetryError_Reason_REASON_SLOW_CONSUMER = 5
};
bool RangeFeedRetryError_Reason_IsValid(int value);
const RangeFeedRetryError_Reason RangeFeedRetryError_Reason_Reason_MIN = RangeFeedRetryError_Reason_REASON_REPLICA_REMOVED;
const RangeFeedRetryError_Reason RangeFeedRetryError_Reason_Reason_MAX = RangeFeedRetryError_Reason_REASON_SLOW_CONSUMER;
const int RangeFeedRetryError_Reason_Reason_ARRAYSIZE = RangeFeedRetryError_Reason_Reason_MAX + 1;

enum TransactionAbortedReason {
  ABORT_REASON_UNKNOWN = 0,
  ABORT_REASON_ABORTED_RECORD_FOUND = 1,
  ABORT_REASON_CLIENT_REJECT = 3,
  ABORT_REASON_PUSHER_ABORTED = 4,
  ABORT_REASON_ABORT_SPAN = 5,
  ABORT_REASON_ALREADY_COMMITTED_OR_ROLLED_BACK_POSSIBLE_REPLAY = 6,
  ABORT_REASON_NEW_LEASE_PREVENTS_TXN = 8,
  ABORT_REASON_TIMESTAMP_CACHE_REJECTED = 7
};
bool TransactionAbortedReason_IsValid(int value);
const TransactionAbortedReason TransactionAbortedReason_MIN = ABORT_REASON_UNKNOWN;
const TransactionAbortedReason TransactionAbortedReason_MAX = ABORT_REASON_NEW_LEASE_PREVENTS_TXN;
const int TransactionAbortedReason_ARRAYSIZE = TransactionAbortedReason_MAX + 1;

enum TransactionRetryReason {
  RETRY_REASON_UNKNOWN = 0,
  RETRY_WRITE_TOO_OLD = 1,
  RETRY_SERIALIZABLE = 3,
  RETRY_ASYNC_WRITE_FAILURE = 5,
  RETRY_COMMIT_DEADLINE_EXCEEDED = 6
};
bool TransactionRetryReason_IsValid(int value);
const TransactionRetryReason TransactionRetryReason_MIN = RETRY_REASON_UNKNOWN;
const TransactionRetryReason TransactionRetryReason_MAX = RETRY_COMMIT_DEADLINE_EXCEEDED;
const int TransactionRetryReason_ARRAYSIZE = TransactionRetryReason_MAX + 1;

enum TransactionRestart {
  NONE = 0,
  BACKOFF = 1,
  IMMEDIATE = 2
};
bool TransactionRestart_IsValid(int value);
const TransactionRestart TransactionRestart_MIN = NONE;
const TransactionRestart TransactionRestart_MAX = IMMEDIATE;
const int TransactionRestart_ARRAYSIZE = TransactionRestart_MAX + 1;

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

class NotLeaseHolderError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.NotLeaseHolderError) */ {
 public:
  NotLeaseHolderError();
  virtual ~NotLeaseHolderError();

  NotLeaseHolderError(const NotLeaseHolderError& from);

  inline NotLeaseHolderError& operator=(const NotLeaseHolderError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  NotLeaseHolderError(NotLeaseHolderError&& from) noexcept
    : NotLeaseHolderError() {
    *this = ::std::move(from);
  }

  inline NotLeaseHolderError& operator=(NotLeaseHolderError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const NotLeaseHolderError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const NotLeaseHolderError* internal_default_instance() {
    return reinterpret_cast<const NotLeaseHolderError*>(
               &_NotLeaseHolderError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  void Swap(NotLeaseHolderError* other);
  friend void swap(NotLeaseHolderError& a, NotLeaseHolderError& b) {
    a.Swap(&b);
  }

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

  inline NotLeaseHolderError* New() const final {
    return CreateMaybeMessage<NotLeaseHolderError>(NULL);
  }

  NotLeaseHolderError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<NotLeaseHolderError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const NotLeaseHolderError& from);
  void MergeFrom(const NotLeaseHolderError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(NotLeaseHolderError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_custom_msg() const;
  void clear_custom_msg();
  static const int kCustomMsgFieldNumber = 5;
  const ::std::string& custom_msg() const;
  void set_custom_msg(const ::std::string& value);
  #if LANG_CXX11
  void set_custom_msg(::std::string&& value);
  #endif
  void set_custom_msg(const char* value);
  void set_custom_msg(const char* value, size_t size);
  ::std::string* mutable_custom_msg();
  ::std::string* release_custom_msg();
  void set_allocated_custom_msg(::std::string* custom_msg);

  bool has_replica() const;
  void clear_replica();
  static const int kReplicaFieldNumber = 1;
  private:
  const ::cockroach::roachpb::ReplicaDescriptor& _internal_replica() const;
  public:
  const ::cockroach::roachpb::ReplicaDescriptor& replica() const;
  ::cockroach::roachpb::ReplicaDescriptor* release_replica();
  ::cockroach::roachpb::ReplicaDescriptor* mutable_replica();
  void set_allocated_replica(::cockroach::roachpb::ReplicaDescriptor* replica);

  // optional .cockroach.roachpb.ReplicaDescriptor lease_holder = 2;
  bool has_lease_holder() const;
  void clear_lease_holder();
  static const int kLeaseHolderFieldNumber = 2;
  private:
  const ::cockroach::roachpb::ReplicaDescriptor& _internal_lease_holder() const;
  public:
  const ::cockroach::roachpb::ReplicaDescriptor& lease_holder() const;
  ::cockroach::roachpb::ReplicaDescriptor* release_lease_holder();
  ::cockroach::roachpb::ReplicaDescriptor* mutable_lease_holder();
  void set_allocated_lease_holder(::cockroach::roachpb::ReplicaDescriptor* lease_holder);

  // optional .cockroach.roachpb.Lease lease = 4;
  bool has_lease() const;
  void clear_lease();
  static const int kLeaseFieldNumber = 4;
  private:
  const ::cockroach::roachpb::Lease& _internal_lease() const;
  public:
  const ::cockroach::roachpb::Lease& lease() const;
  ::cockroach::roachpb::Lease* release_lease();
  ::cockroach::roachpb::Lease* mutable_lease();
  void set_allocated_lease(::cockroach::roachpb::Lease* lease);

  bool has_range_id() const;
  void clear_range_id();
  static const int kRangeIdFieldNumber = 3;
  ::google::protobuf::int64 range_id() const;
  void set_range_id(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.NotLeaseHolderError)
 private:
  void set_has_replica();
  void clear_has_replica();
  void set_has_lease_holder();
  void clear_has_lease_holder();
  void set_has_lease();
  void clear_has_lease();
  void set_has_range_id();
  void clear_has_range_id();
  void set_has_custom_msg();
  void clear_has_custom_msg();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr custom_msg_;
  ::cockroach::roachpb::ReplicaDescriptor* replica_;
  ::cockroach::roachpb::ReplicaDescriptor* lease_holder_;
  ::cockroach::roachpb::Lease* lease_;
  ::google::protobuf::int64 range_id_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class NodeUnavailableError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.NodeUnavailableError) */ {
 public:
  NodeUnavailableError();
  virtual ~NodeUnavailableError();

  NodeUnavailableError(const NodeUnavailableError& from);

  inline NodeUnavailableError& operator=(const NodeUnavailableError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  NodeUnavailableError(NodeUnavailableError&& from) noexcept
    : NodeUnavailableError() {
    *this = ::std::move(from);
  }

  inline NodeUnavailableError& operator=(NodeUnavailableError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const NodeUnavailableError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const NodeUnavailableError* internal_default_instance() {
    return reinterpret_cast<const NodeUnavailableError*>(
               &_NodeUnavailableError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  void Swap(NodeUnavailableError* other);
  friend void swap(NodeUnavailableError& a, NodeUnavailableError& b) {
    a.Swap(&b);
  }

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

  inline NodeUnavailableError* New() const final {
    return CreateMaybeMessage<NodeUnavailableError>(NULL);
  }

  NodeUnavailableError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<NodeUnavailableError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const NodeUnavailableError& from);
  void MergeFrom(const NodeUnavailableError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(NodeUnavailableError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.NodeUnavailableError)
 private:

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class UnsupportedRequestError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.UnsupportedRequestError) */ {
 public:
  UnsupportedRequestError();
  virtual ~UnsupportedRequestError();

  UnsupportedRequestError(const UnsupportedRequestError& from);

  inline UnsupportedRequestError& operator=(const UnsupportedRequestError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  UnsupportedRequestError(UnsupportedRequestError&& from) noexcept
    : UnsupportedRequestError() {
    *this = ::std::move(from);
  }

  inline UnsupportedRequestError& operator=(UnsupportedRequestError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const UnsupportedRequestError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const UnsupportedRequestError* internal_default_instance() {
    return reinterpret_cast<const UnsupportedRequestError*>(
               &_UnsupportedRequestError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  void Swap(UnsupportedRequestError* other);
  friend void swap(UnsupportedRequestError& a, UnsupportedRequestError& b) {
    a.Swap(&b);
  }

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

  inline UnsupportedRequestError* New() const final {
    return CreateMaybeMessage<UnsupportedRequestError>(NULL);
  }

  UnsupportedRequestError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<UnsupportedRequestError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const UnsupportedRequestError& from);
  void MergeFrom(const UnsupportedRequestError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(UnsupportedRequestError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.UnsupportedRequestError)
 private:

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RangeNotFoundError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.RangeNotFoundError) */ {
 public:
  RangeNotFoundError();
  virtual ~RangeNotFoundError();

  RangeNotFoundError(const RangeNotFoundError& from);

  inline RangeNotFoundError& operator=(const RangeNotFoundError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RangeNotFoundError(RangeNotFoundError&& from) noexcept
    : RangeNotFoundError() {
    *this = ::std::move(from);
  }

  inline RangeNotFoundError& operator=(RangeNotFoundError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const RangeNotFoundError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RangeNotFoundError* internal_default_instance() {
    return reinterpret_cast<const RangeNotFoundError*>(
               &_RangeNotFoundError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  void Swap(RangeNotFoundError* other);
  friend void swap(RangeNotFoundError& a, RangeNotFoundError& b) {
    a.Swap(&b);
  }

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

  inline RangeNotFoundError* New() const final {
    return CreateMaybeMessage<RangeNotFoundError>(NULL);
  }

  RangeNotFoundError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RangeNotFoundError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const RangeNotFoundError& from);
  void MergeFrom(const RangeNotFoundError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RangeNotFoundError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_range_id() const;
  void clear_range_id();
  static const int kRangeIdFieldNumber = 1;
  ::google::protobuf::int64 range_id() const;
  void set_range_id(::google::protobuf::int64 value);

  bool has_store_id() const;
  void clear_store_id();
  static const int kStoreIdFieldNumber = 2;
  ::google::protobuf::int64 store_id() const;
  void set_store_id(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.RangeNotFoundError)
 private:
  void set_has_range_id();
  void clear_has_range_id();
  void set_has_store_id();
  void clear_has_store_id();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int64 range_id_;
  ::google::protobuf::int64 store_id_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RangeKeyMismatchError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.RangeKeyMismatchError) */ {
 public:
  RangeKeyMismatchError();
  virtual ~RangeKeyMismatchError();

  RangeKeyMismatchError(const RangeKeyMismatchError& from);

  inline RangeKeyMismatchError& operator=(const RangeKeyMismatchError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RangeKeyMismatchError(RangeKeyMismatchError&& from) noexcept
    : RangeKeyMismatchError() {
    *this = ::std::move(from);
  }

  inline RangeKeyMismatchError& operator=(RangeKeyMismatchError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const RangeKeyMismatchError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RangeKeyMismatchError* internal_default_instance() {
    return reinterpret_cast<const RangeKeyMismatchError*>(
               &_RangeKeyMismatchError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  void Swap(RangeKeyMismatchError* other);
  friend void swap(RangeKeyMismatchError& a, RangeKeyMismatchError& b) {
    a.Swap(&b);
  }

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

  inline RangeKeyMismatchError* New() const final {
    return CreateMaybeMessage<RangeKeyMismatchError>(NULL);
  }

  RangeKeyMismatchError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RangeKeyMismatchError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const RangeKeyMismatchError& from);
  void MergeFrom(const RangeKeyMismatchError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RangeKeyMismatchError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_request_start_key() const;
  void clear_request_start_key();
  static const int kRequestStartKeyFieldNumber = 1;
  const ::std::string& request_start_key() const;
  void set_request_start_key(const ::std::string& value);
  #if LANG_CXX11
  void set_request_start_key(::std::string&& value);
  #endif
  void set_request_start_key(const char* value);
  void set_request_start_key(const void* value, size_t size);
  ::std::string* mutable_request_start_key();
  ::std::string* release_request_start_key();
  void set_allocated_request_start_key(::std::string* request_start_key);

  bool has_request_end_key() const;
  void clear_request_end_key();
  static const int kRequestEndKeyFieldNumber = 2;
  const ::std::string& request_end_key() const;
  void set_request_end_key(const ::std::string& value);
  #if LANG_CXX11
  void set_request_end_key(::std::string&& value);
  #endif
  void set_request_end_key(const char* value);
  void set_request_end_key(const void* value, size_t size);
  ::std::string* mutable_request_end_key();
  ::std::string* release_request_end_key();
  void set_allocated_request_end_key(::std::string* request_end_key);

  bool has_mismatched_range() const;
  void clear_mismatched_range();
  static const int kMismatchedRangeFieldNumber = 3;
  private:
  const ::cockroach::roachpb::RangeDescriptor& _internal_mismatched_range() const;
  public:
  const ::cockroach::roachpb::RangeDescriptor& mismatched_range() const;
  ::cockroach::roachpb::RangeDescriptor* release_mismatched_range();
  ::cockroach::roachpb::RangeDescriptor* mutable_mismatched_range();
  void set_allocated_mismatched_range(::cockroach::roachpb::RangeDescriptor* mismatched_range);

  // optional .cockroach.roachpb.RangeDescriptor suggested_range = 4;
  bool has_suggested_range() const;
  void clear_suggested_range();
  static const int kSuggestedRangeFieldNumber = 4;
  private:
  const ::cockroach::roachpb::RangeDescriptor& _internal_suggested_range() const;
  public:
  const ::cockroach::roachpb::RangeDescriptor& suggested_range() const;
  ::cockroach::roachpb::RangeDescriptor* release_suggested_range();
  ::cockroach::roachpb::RangeDescriptor* mutable_suggested_range();
  void set_allocated_suggested_range(::cockroach::roachpb::RangeDescriptor* suggested_range);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.RangeKeyMismatchError)
 private:
  void set_has_request_start_key();
  void clear_has_request_start_key();
  void set_has_request_end_key();
  void clear_has_request_end_key();
  void set_has_mismatched_range();
  void clear_has_mismatched_range();
  void set_has_suggested_range();
  void clear_has_suggested_range();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr request_start_key_;
  ::google::protobuf::internal::ArenaStringPtr request_end_key_;
  ::cockroach::roachpb::RangeDescriptor* mismatched_range_;
  ::cockroach::roachpb::RangeDescriptor* suggested_range_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ReadWithinUncertaintyIntervalError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.ReadWithinUncertaintyIntervalError) */ {
 public:
  ReadWithinUncertaintyIntervalError();
  virtual ~ReadWithinUncertaintyIntervalError();

  ReadWithinUncertaintyIntervalError(const ReadWithinUncertaintyIntervalError& from);

  inline ReadWithinUncertaintyIntervalError& operator=(const ReadWithinUncertaintyIntervalError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReadWithinUncertaintyIntervalError(ReadWithinUncertaintyIntervalError&& from) noexcept
    : ReadWithinUncertaintyIntervalError() {
    *this = ::std::move(from);
  }

  inline ReadWithinUncertaintyIntervalError& operator=(ReadWithinUncertaintyIntervalError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ReadWithinUncertaintyIntervalError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReadWithinUncertaintyIntervalError* internal_default_instance() {
    return reinterpret_cast<const ReadWithinUncertaintyIntervalError*>(
               &_ReadWithinUncertaintyIntervalError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  void Swap(ReadWithinUncertaintyIntervalError* other);
  friend void swap(ReadWithinUncertaintyIntervalError& a, ReadWithinUncertaintyIntervalError& b) {
    a.Swap(&b);
  }

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

  inline ReadWithinUncertaintyIntervalError* New() const final {
    return CreateMaybeMessage<ReadWithinUncertaintyIntervalError>(NULL);
  }

  ReadWithinUncertaintyIntervalError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReadWithinUncertaintyIntervalError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const ReadWithinUncertaintyIntervalError& from);
  void MergeFrom(const ReadWithinUncertaintyIntervalError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ReadWithinUncertaintyIntervalError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  int observed_timestamps_size() const;
  void clear_observed_timestamps();
  static const int kObservedTimestampsFieldNumber = 4;
  ::cockroach::roachpb::ObservedTimestamp* mutable_observed_timestamps(int index);
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ObservedTimestamp >*
      mutable_observed_timestamps();
  const ::cockroach::roachpb::ObservedTimestamp& observed_timestamps(int index) const;
  ::cockroach::roachpb::ObservedTimestamp* add_observed_timestamps();
  const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ObservedTimestamp >&
      observed_timestamps() const;

  bool has_read_timestamp() const;
  void clear_read_timestamp();
  static const int kReadTimestampFieldNumber = 1;
  private:
  const ::cockroach::util::hlc::Timestamp& _internal_read_timestamp() const;
  public:
  const ::cockroach::util::hlc::Timestamp& read_timestamp() const;
  ::cockroach::util::hlc::Timestamp* release_read_timestamp();
  ::cockroach::util::hlc::Timestamp* mutable_read_timestamp();
  void set_allocated_read_timestamp(::cockroach::util::hlc::Timestamp* read_timestamp);

  bool has_existing_timestamp() const;
  void clear_existing_timestamp();
  static const int kExistingTimestampFieldNumber = 2;
  private:
  const ::cockroach::util::hlc::Timestamp& _internal_existing_timestamp() const;
  public:
  const ::cockroach::util::hlc::Timestamp& existing_timestamp() const;
  ::cockroach::util::hlc::Timestamp* release_existing_timestamp();
  ::cockroach::util::hlc::Timestamp* mutable_existing_timestamp();
  void set_allocated_existing_timestamp(::cockroach::util::hlc::Timestamp* existing_timestamp);

  // optional .cockroach.util.hlc.Timestamp max_timestamp = 3;
  bool has_max_timestamp() const;
  void clear_max_timestamp();
  static const int kMaxTimestampFieldNumber = 3;
  private:
  const ::cockroach::util::hlc::Timestamp& _internal_max_timestamp() const;
  public:
  const ::cockroach::util::hlc::Timestamp& max_timestamp() const;
  ::cockroach::util::hlc::Timestamp* release_max_timestamp();
  ::cockroach::util::hlc::Timestamp* mutable_max_timestamp();
  void set_allocated_max_timestamp(::cockroach::util::hlc::Timestamp* max_timestamp);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.ReadWithinUncertaintyIntervalError)
 private:
  void set_has_read_timestamp();
  void clear_has_read_timestamp();
  void set_has_existing_timestamp();
  void clear_has_existing_timestamp();
  void set_has_max_timestamp();
  void clear_has_max_timestamp();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ObservedTimestamp > observed_timestamps_;
  ::cockroach::util::hlc::Timestamp* read_timestamp_;
  ::cockroach::util::hlc::Timestamp* existing_timestamp_;
  ::cockroach::util::hlc::Timestamp* max_timestamp_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TransactionAbortedError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.TransactionAbortedError) */ {
 public:
  TransactionAbortedError();
  virtual ~TransactionAbortedError();

  TransactionAbortedError(const TransactionAbortedError& from);

  inline TransactionAbortedError& operator=(const TransactionAbortedError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TransactionAbortedError(TransactionAbortedError&& from) noexcept
    : TransactionAbortedError() {
    *this = ::std::move(from);
  }

  inline TransactionAbortedError& operator=(TransactionAbortedError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TransactionAbortedError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TransactionAbortedError* internal_default_instance() {
    return reinterpret_cast<const TransactionAbortedError*>(
               &_TransactionAbortedError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  void Swap(TransactionAbortedError* other);
  friend void swap(TransactionAbortedError& a, TransactionAbortedError& b) {
    a.Swap(&b);
  }

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

  inline TransactionAbortedError* New() const final {
    return CreateMaybeMessage<TransactionAbortedError>(NULL);
  }

  TransactionAbortedError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TransactionAbortedError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const TransactionAbortedError& from);
  void MergeFrom(const TransactionAbortedError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TransactionAbortedError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_reason() const;
  void clear_reason();
  static const int kReasonFieldNumber = 1;
  ::cockroach::roachpb::TransactionAbortedReason reason() const;
  void set_reason(::cockroach::roachpb::TransactionAbortedReason value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.TransactionAbortedError)
 private:
  void set_has_reason();
  void clear_has_reason();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  int reason_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TransactionPushError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.TransactionPushError) */ {
 public:
  TransactionPushError();
  virtual ~TransactionPushError();

  TransactionPushError(const TransactionPushError& from);

  inline TransactionPushError& operator=(const TransactionPushError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TransactionPushError(TransactionPushError&& from) noexcept
    : TransactionPushError() {
    *this = ::std::move(from);
  }

  inline TransactionPushError& operator=(TransactionPushError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TransactionPushError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TransactionPushError* internal_default_instance() {
    return reinterpret_cast<const TransactionPushError*>(
               &_TransactionPushError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  void Swap(TransactionPushError* other);
  friend void swap(TransactionPushError& a, TransactionPushError& b) {
    a.Swap(&b);
  }

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

  inline TransactionPushError* New() const final {
    return CreateMaybeMessage<TransactionPushError>(NULL);
  }

  TransactionPushError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TransactionPushError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const TransactionPushError& from);
  void MergeFrom(const TransactionPushError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TransactionPushError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_pushee_txn() const;
  void clear_pushee_txn();
  static const int kPusheeTxnFieldNumber = 1;
  private:
  const ::cockroach::roachpb::Transaction& _internal_pushee_txn() const;
  public:
  const ::cockroach::roachpb::Transaction& pushee_txn() const;
  ::cockroach::roachpb::Transaction* release_pushee_txn();
  ::cockroach::roachpb::Transaction* mutable_pushee_txn();
  void set_allocated_pushee_txn(::cockroach::roachpb::Transaction* pushee_txn);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.TransactionPushError)
 private:
  void set_has_pushee_txn();
  void clear_has_pushee_txn();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::cockroach::roachpb::Transaction* pushee_txn_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TransactionRetryError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.TransactionRetryError) */ {
 public:
  TransactionRetryError();
  virtual ~TransactionRetryError();

  TransactionRetryError(const TransactionRetryError& from);

  inline TransactionRetryError& operator=(const TransactionRetryError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TransactionRetryError(TransactionRetryError&& from) noexcept
    : TransactionRetryError() {
    *this = ::std::move(from);
  }

  inline TransactionRetryError& operator=(TransactionRetryError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TransactionRetryError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TransactionRetryError* internal_default_instance() {
    return reinterpret_cast<const TransactionRetryError*>(
               &_TransactionRetryError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  void Swap(TransactionRetryError* other);
  friend void swap(TransactionRetryError& a, TransactionRetryError& b) {
    a.Swap(&b);
  }

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

  inline TransactionRetryError* New() const final {
    return CreateMaybeMessage<TransactionRetryError>(NULL);
  }

  TransactionRetryError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TransactionRetryError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const TransactionRetryError& from);
  void MergeFrom(const TransactionRetryError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TransactionRetryError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_extra_msg() const;
  void clear_extra_msg();
  static const int kExtraMsgFieldNumber = 2;
  const ::std::string& extra_msg() const;
  void set_extra_msg(const ::std::string& value);
  #if LANG_CXX11
  void set_extra_msg(::std::string&& value);
  #endif
  void set_extra_msg(const char* value);
  void set_extra_msg(const char* value, size_t size);
  ::std::string* mutable_extra_msg();
  ::std::string* release_extra_msg();
  void set_allocated_extra_msg(::std::string* extra_msg);

  bool has_reason() const;
  void clear_reason();
  static const int kReasonFieldNumber = 1;
  ::cockroach::roachpb::TransactionRetryReason reason() const;
  void set_reason(::cockroach::roachpb::TransactionRetryReason value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.TransactionRetryError)
 private:
  void set_has_reason();
  void clear_has_reason();
  void set_has_extra_msg();
  void clear_has_extra_msg();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr extra_msg_;
  int reason_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TransactionStatusError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.TransactionStatusError) */ {
 public:
  TransactionStatusError();
  virtual ~TransactionStatusError();

  TransactionStatusError(const TransactionStatusError& from);

  inline TransactionStatusError& operator=(const TransactionStatusError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TransactionStatusError(TransactionStatusError&& from) noexcept
    : TransactionStatusError() {
    *this = ::std::move(from);
  }

  inline TransactionStatusError& operator=(TransactionStatusError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TransactionStatusError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TransactionStatusError* internal_default_instance() {
    return reinterpret_cast<const TransactionStatusError*>(
               &_TransactionStatusError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  void Swap(TransactionStatusError* other);
  friend void swap(TransactionStatusError& a, TransactionStatusError& b) {
    a.Swap(&b);
  }

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

  inline TransactionStatusError* New() const final {
    return CreateMaybeMessage<TransactionStatusError>(NULL);
  }

  TransactionStatusError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TransactionStatusError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const TransactionStatusError& from);
  void MergeFrom(const TransactionStatusError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TransactionStatusError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

  typedef TransactionStatusError_Reason Reason;
  static const Reason REASON_UNKNOWN =
    TransactionStatusError_Reason_REASON_UNKNOWN;
  static const Reason REASON_TXN_COMMITTED =
    TransactionStatusError_Reason_REASON_TXN_COMMITTED;
  static inline bool Reason_IsValid(int value) {
    return TransactionStatusError_Reason_IsValid(value);
  }
  static const Reason Reason_MIN =
    TransactionStatusError_Reason_Reason_MIN;
  static const Reason Reason_MAX =
    TransactionStatusError_Reason_Reason_MAX;
  static const int Reason_ARRAYSIZE =
    TransactionStatusError_Reason_Reason_ARRAYSIZE;

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

  bool has_msg() const;
  void clear_msg();
  static const int kMsgFieldNumber = 1;
  const ::std::string& msg() const;
  void set_msg(const ::std::string& value);
  #if LANG_CXX11
  void set_msg(::std::string&& value);
  #endif
  void set_msg(const char* value);
  void set_msg(const char* value, size_t size);
  ::std::string* mutable_msg();
  ::std::string* release_msg();
  void set_allocated_msg(::std::string* msg);

  bool has_reason() const;
  void clear_reason();
  static const int kReasonFieldNumber = 2;
  ::cockroach::roachpb::TransactionStatusError_Reason reason() const;
  void set_reason(::cockroach::roachpb::TransactionStatusError_Reason value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.TransactionStatusError)
 private:
  void set_has_msg();
  void clear_has_msg();
  void set_has_reason();
  void clear_has_reason();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr msg_;
  int reason_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class WriteIntentError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.WriteIntentError) */ {
 public:
  WriteIntentError();
  virtual ~WriteIntentError();

  WriteIntentError(const WriteIntentError& from);

  inline WriteIntentError& operator=(const WriteIntentError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  WriteIntentError(WriteIntentError&& from) noexcept
    : WriteIntentError() {
    *this = ::std::move(from);
  }

  inline WriteIntentError& operator=(WriteIntentError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const WriteIntentError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const WriteIntentError* internal_default_instance() {
    return reinterpret_cast<const WriteIntentError*>(
               &_WriteIntentError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  void Swap(WriteIntentError* other);
  friend void swap(WriteIntentError& a, WriteIntentError& b) {
    a.Swap(&b);
  }

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

  inline WriteIntentError* New() const final {
    return CreateMaybeMessage<WriteIntentError>(NULL);
  }

  WriteIntentError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<WriteIntentError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const WriteIntentError& from);
  void MergeFrom(const WriteIntentError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(WriteIntentError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  int intents_size() const;
  void clear_intents();
  static const int kIntentsFieldNumber = 1;
  ::cockroach::roachpb::Intent* mutable_intents(int index);
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::Intent >*
      mutable_intents();
  const ::cockroach::roachpb::Intent& intents(int index) const;
  ::cockroach::roachpb::Intent* add_intents();
  const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::Intent >&
      intents() const;

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.WriteIntentError)
 private:

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::Intent > intents_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class WriteTooOldError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.WriteTooOldError) */ {
 public:
  WriteTooOldError();
  virtual ~WriteTooOldError();

  WriteTooOldError(const WriteTooOldError& from);

  inline WriteTooOldError& operator=(const WriteTooOldError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  WriteTooOldError(WriteTooOldError&& from) noexcept
    : WriteTooOldError() {
    *this = ::std::move(from);
  }

  inline WriteTooOldError& operator=(WriteTooOldError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const WriteTooOldError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const WriteTooOldError* internal_default_instance() {
    return reinterpret_cast<const WriteTooOldError*>(
               &_WriteTooOldError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  void Swap(WriteTooOldError* other);
  friend void swap(WriteTooOldError& a, WriteTooOldError& b) {
    a.Swap(&b);
  }

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

  inline WriteTooOldError* New() const final {
    return CreateMaybeMessage<WriteTooOldError>(NULL);
  }

  WriteTooOldError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<WriteTooOldError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const WriteTooOldError& from);
  void MergeFrom(const WriteTooOldError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(WriteTooOldError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_timestamp() const;
  void clear_timestamp();
  static const int kTimestampFieldNumber = 1;
  private:
  const ::cockroach::util::hlc::Timestamp& _internal_timestamp() const;
  public:
  const ::cockroach::util::hlc::Timestamp& timestamp() const;
  ::cockroach::util::hlc::Timestamp* release_timestamp();
  ::cockroach::util::hlc::Timestamp* mutable_timestamp();
  void set_allocated_timestamp(::cockroach::util::hlc::Timestamp* timestamp);

  bool has_actual_timestamp() const;
  void clear_actual_timestamp();
  static const int kActualTimestampFieldNumber = 2;
  private:
  const ::cockroach::util::hlc::Timestamp& _internal_actual_timestamp() const;
  public:
  const ::cockroach::util::hlc::Timestamp& actual_timestamp() const;
  ::cockroach::util::hlc::Timestamp* release_actual_timestamp();
  ::cockroach::util::hlc::Timestamp* mutable_actual_timestamp();
  void set_allocated_actual_timestamp(::cockroach::util::hlc::Timestamp* actual_timestamp);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.WriteTooOldError)
 private:
  void set_has_timestamp();
  void clear_has_timestamp();
  void set_has_actual_timestamp();
  void clear_has_actual_timestamp();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::cockroach::util::hlc::Timestamp* timestamp_;
  ::cockroach::util::hlc::Timestamp* actual_timestamp_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class OpRequiresTxnError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.OpRequiresTxnError) */ {
 public:
  OpRequiresTxnError();
  virtual ~OpRequiresTxnError();

  OpRequiresTxnError(const OpRequiresTxnError& from);

  inline OpRequiresTxnError& operator=(const OpRequiresTxnError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  OpRequiresTxnError(OpRequiresTxnError&& from) noexcept
    : OpRequiresTxnError() {
    *this = ::std::move(from);
  }

  inline OpRequiresTxnError& operator=(OpRequiresTxnError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const OpRequiresTxnError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const OpRequiresTxnError* internal_default_instance() {
    return reinterpret_cast<const OpRequiresTxnError*>(
               &_OpRequiresTxnError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  void Swap(OpRequiresTxnError* other);
  friend void swap(OpRequiresTxnError& a, OpRequiresTxnError& b) {
    a.Swap(&b);
  }

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

  inline OpRequiresTxnError* New() const final {
    return CreateMaybeMessage<OpRequiresTxnError>(NULL);
  }

  OpRequiresTxnError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<OpRequiresTxnError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const OpRequiresTxnError& from);
  void MergeFrom(const OpRequiresTxnError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(OpRequiresTxnError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.OpRequiresTxnError)
 private:

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ConditionFailedError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.ConditionFailedError) */ {
 public:
  ConditionFailedError();
  virtual ~ConditionFailedError();

  ConditionFailedError(const ConditionFailedError& from);

  inline ConditionFailedError& operator=(const ConditionFailedError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ConditionFailedError(ConditionFailedError&& from) noexcept
    : ConditionFailedError() {
    *this = ::std::move(from);
  }

  inline ConditionFailedError& operator=(ConditionFailedError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ConditionFailedError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ConditionFailedError* internal_default_instance() {
    return reinterpret_cast<const ConditionFailedError*>(
               &_ConditionFailedError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  void Swap(ConditionFailedError* other);
  friend void swap(ConditionFailedError& a, ConditionFailedError& b) {
    a.Swap(&b);
  }

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

  inline ConditionFailedError* New() const final {
    return CreateMaybeMessage<ConditionFailedError>(NULL);
  }

  ConditionFailedError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ConditionFailedError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const ConditionFailedError& from);
  void MergeFrom(const ConditionFailedError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ConditionFailedError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  // optional .cockroach.roachpb.Value actual_value = 1;
  bool has_actual_value() const;
  void clear_actual_value();
  static const int kActualValueFieldNumber = 1;
  private:
  const ::cockroach::roachpb::Value& _internal_actual_value() const;
  public:
  const ::cockroach::roachpb::Value& actual_value() const;
  ::cockroach::roachpb::Value* release_actual_value();
  ::cockroach::roachpb::Value* mutable_actual_value();
  void set_allocated_actual_value(::cockroach::roachpb::Value* actual_value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.ConditionFailedError)
 private:
  void set_has_actual_value();
  void clear_has_actual_value();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::cockroach::roachpb::Value* actual_value_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class LeaseRejectedError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.LeaseRejectedError) */ {
 public:
  LeaseRejectedError();
  virtual ~LeaseRejectedError();

  LeaseRejectedError(const LeaseRejectedError& from);

  inline LeaseRejectedError& operator=(const LeaseRejectedError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  LeaseRejectedError(LeaseRejectedError&& from) noexcept
    : LeaseRejectedError() {
    *this = ::std::move(from);
  }

  inline LeaseRejectedError& operator=(LeaseRejectedError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const LeaseRejectedError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LeaseRejectedError* internal_default_instance() {
    return reinterpret_cast<const LeaseRejectedError*>(
               &_LeaseRejectedError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  void Swap(LeaseRejectedError* other);
  friend void swap(LeaseRejectedError& a, LeaseRejectedError& b) {
    a.Swap(&b);
  }

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

  inline LeaseRejectedError* New() const final {
    return CreateMaybeMessage<LeaseRejectedError>(NULL);
  }

  LeaseRejectedError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<LeaseRejectedError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const LeaseRejectedError& from);
  void MergeFrom(const LeaseRejectedError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(LeaseRejectedError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_message() const;
  void clear_message();
  static const int kMessageFieldNumber = 1;
  const ::std::string& message() const;
  void set_message(const ::std::string& value);
  #if LANG_CXX11
  void set_message(::std::string&& value);
  #endif
  void set_message(const char* value);
  void set_message(const char* value, size_t size);
  ::std::string* mutable_message();
  ::std::string* release_message();
  void set_allocated_message(::std::string* message);

  bool has_requested() const;
  void clear_requested();
  static const int kRequestedFieldNumber = 2;
  private:
  const ::cockroach::roachpb::Lease& _internal_requested() const;
  public:
  const ::cockroach::roachpb::Lease& requested() const;
  ::cockroach::roachpb::Lease* release_requested();
  ::cockroach::roachpb::Lease* mutable_requested();
  void set_allocated_requested(::cockroach::roachpb::Lease* requested);

  bool has_existing() const;
  void clear_existing();
  static const int kExistingFieldNumber = 3;
  private:
  const ::cockroach::roachpb::Lease& _internal_existing() const;
  public:
  const ::cockroach::roachpb::Lease& existing() const;
  ::cockroach::roachpb::Lease* release_existing();
  ::cockroach::roachpb::Lease* mutable_existing();
  void set_allocated_existing(::cockroach::roachpb::Lease* existing);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.LeaseRejectedError)
 private:
  void set_has_message();
  void clear_has_message();
  void set_has_requested();
  void clear_has_requested();
  void set_has_existing();
  void clear_has_existing();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr message_;
  ::cockroach::roachpb::Lease* requested_;
  ::cockroach::roachpb::Lease* existing_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SendError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.SendError) */ {
 public:
  SendError();
  virtual ~SendError();

  SendError(const SendError& from);

  inline SendError& operator=(const SendError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SendError(SendError&& from) noexcept
    : SendError() {
    *this = ::std::move(from);
  }

  inline SendError& operator=(SendError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const SendError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const SendError* internal_default_instance() {
    return reinterpret_cast<const SendError*>(
               &_SendError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    15;

  void Swap(SendError* other);
  friend void swap(SendError& a, SendError& b) {
    a.Swap(&b);
  }

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

  inline SendError* New() const final {
    return CreateMaybeMessage<SendError>(NULL);
  }

  SendError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<SendError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const SendError& from);
  void MergeFrom(const SendError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(SendError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_message() const;
  void clear_message();
  static const int kMessageFieldNumber = 1;
  const ::std::string& message() const;
  void set_message(const ::std::string& value);
  #if LANG_CXX11
  void set_message(::std::string&& value);
  #endif
  void set_message(const char* value);
  void set_message(const char* value, size_t size);
  ::std::string* mutable_message();
  ::std::string* release_message();
  void set_allocated_message(::std::string* message);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.SendError)
 private:
  void set_has_message();
  void clear_has_message();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr message_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class AmbiguousResultError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.AmbiguousResultError) */ {
 public:
  AmbiguousResultError();
  virtual ~AmbiguousResultError();

  AmbiguousResultError(const AmbiguousResultError& from);

  inline AmbiguousResultError& operator=(const AmbiguousResultError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  AmbiguousResultError(AmbiguousResultError&& from) noexcept
    : AmbiguousResultError() {
    *this = ::std::move(from);
  }

  inline AmbiguousResultError& operator=(AmbiguousResultError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const AmbiguousResultError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const AmbiguousResultError* internal_default_instance() {
    return reinterpret_cast<const AmbiguousResultError*>(
               &_AmbiguousResultError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    16;

  void Swap(AmbiguousResultError* other);
  friend void swap(AmbiguousResultError& a, AmbiguousResultError& b) {
    a.Swap(&b);
  }

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

  inline AmbiguousResultError* New() const final {
    return CreateMaybeMessage<AmbiguousResultError>(NULL);
  }

  AmbiguousResultError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<AmbiguousResultError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const AmbiguousResultError& from);
  void MergeFrom(const AmbiguousResultError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(AmbiguousResultError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_message() const;
  void clear_message();
  static const int kMessageFieldNumber = 1;
  const ::std::string& message() const;
  void set_message(const ::std::string& value);
  #if LANG_CXX11
  void set_message(::std::string&& value);
  #endif
  void set_message(const char* value);
  void set_message(const char* value, size_t size);
  ::std::string* mutable_message();
  ::std::string* release_message();
  void set_allocated_message(::std::string* message);

  // optional .cockroach.roachpb.Error wrapped_err = 2;
  bool has_wrapped_err() const;
  void clear_wrapped_err();
  static const int kWrappedErrFieldNumber = 2;
  private:
  const ::cockroach::roachpb::Error& _internal_wrapped_err() const;
  public:
  const ::cockroach::roachpb::Error& wrapped_err() const;
  ::cockroach::roachpb::Error* release_wrapped_err();
  ::cockroach::roachpb::Error* mutable_wrapped_err();
  void set_allocated_wrapped_err(::cockroach::roachpb::Error* wrapped_err);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.AmbiguousResultError)
 private:
  void set_has_message();
  void clear_has_message();
  void set_has_wrapped_err();
  void clear_has_wrapped_err();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr message_;
  ::cockroach::roachpb::Error* wrapped_err_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RaftGroupDeletedError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.RaftGroupDeletedError) */ {
 public:
  RaftGroupDeletedError();
  virtual ~RaftGroupDeletedError();

  RaftGroupDeletedError(const RaftGroupDeletedError& from);

  inline RaftGroupDeletedError& operator=(const RaftGroupDeletedError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RaftGroupDeletedError(RaftGroupDeletedError&& from) noexcept
    : RaftGroupDeletedError() {
    *this = ::std::move(from);
  }

  inline RaftGroupDeletedError& operator=(RaftGroupDeletedError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const RaftGroupDeletedError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RaftGroupDeletedError* internal_default_instance() {
    return reinterpret_cast<const RaftGroupDeletedError*>(
               &_RaftGroupDeletedError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    17;

  void Swap(RaftGroupDeletedError* other);
  friend void swap(RaftGroupDeletedError& a, RaftGroupDeletedError& b) {
    a.Swap(&b);
  }

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

  inline RaftGroupDeletedError* New() const final {
    return CreateMaybeMessage<RaftGroupDeletedError>(NULL);
  }

  RaftGroupDeletedError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RaftGroupDeletedError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const RaftGroupDeletedError& from);
  void MergeFrom(const RaftGroupDeletedError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RaftGroupDeletedError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.RaftGroupDeletedError)
 private:

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ReplicaCorruptionError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.ReplicaCorruptionError) */ {
 public:
  ReplicaCorruptionError();
  virtual ~ReplicaCorruptionError();

  ReplicaCorruptionError(const ReplicaCorruptionError& from);

  inline ReplicaCorruptionError& operator=(const ReplicaCorruptionError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReplicaCorruptionError(ReplicaCorruptionError&& from) noexcept
    : ReplicaCorruptionError() {
    *this = ::std::move(from);
  }

  inline ReplicaCorruptionError& operator=(ReplicaCorruptionError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ReplicaCorruptionError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReplicaCorruptionError* internal_default_instance() {
    return reinterpret_cast<const ReplicaCorruptionError*>(
               &_ReplicaCorruptionError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    18;

  void Swap(ReplicaCorruptionError* other);
  friend void swap(ReplicaCorruptionError& a, ReplicaCorruptionError& b) {
    a.Swap(&b);
  }

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

  inline ReplicaCorruptionError* New() const final {
    return CreateMaybeMessage<ReplicaCorruptionError>(NULL);
  }

  ReplicaCorruptionError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReplicaCorruptionError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const ReplicaCorruptionError& from);
  void MergeFrom(const ReplicaCorruptionError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ReplicaCorruptionError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_error_msg() const;
  void clear_error_msg();
  static const int kErrorMsgFieldNumber = 1;
  const ::std::string& error_msg() const;
  void set_error_msg(const ::std::string& value);
  #if LANG_CXX11
  void set_error_msg(::std::string&& value);
  #endif
  void set_error_msg(const char* value);
  void set_error_msg(const char* value, size_t size);
  ::std::string* mutable_error_msg();
  ::std::string* release_error_msg();
  void set_allocated_error_msg(::std::string* error_msg);

  bool has_processed() const;
  void clear_processed();
  static const int kProcessedFieldNumber = 2;
  bool processed() const;
  void set_processed(bool value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.ReplicaCorruptionError)
 private:
  void set_has_error_msg();
  void clear_has_error_msg();
  void set_has_processed();
  void clear_has_processed();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr error_msg_;
  bool processed_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ReplicaTooOldError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.ReplicaTooOldError) */ {
 public:
  ReplicaTooOldError();
  virtual ~ReplicaTooOldError();

  ReplicaTooOldError(const ReplicaTooOldError& from);

  inline ReplicaTooOldError& operator=(const ReplicaTooOldError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ReplicaTooOldError(ReplicaTooOldError&& from) noexcept
    : ReplicaTooOldError() {
    *this = ::std::move(from);
  }

  inline ReplicaTooOldError& operator=(ReplicaTooOldError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ReplicaTooOldError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ReplicaTooOldError* internal_default_instance() {
    return reinterpret_cast<const ReplicaTooOldError*>(
               &_ReplicaTooOldError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    19;

  void Swap(ReplicaTooOldError* other);
  friend void swap(ReplicaTooOldError& a, ReplicaTooOldError& b) {
    a.Swap(&b);
  }

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

  inline ReplicaTooOldError* New() const final {
    return CreateMaybeMessage<ReplicaTooOldError>(NULL);
  }

  ReplicaTooOldError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ReplicaTooOldError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const ReplicaTooOldError& from);
  void MergeFrom(const ReplicaTooOldError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ReplicaTooOldError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_replica_id() const;
  void clear_replica_id();
  static const int kReplicaIdFieldNumber = 1;
  ::google::protobuf::int32 replica_id() const;
  void set_replica_id(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.ReplicaTooOldError)
 private:
  void set_has_replica_id();
  void clear_has_replica_id();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 replica_id_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class StoreNotFoundError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.StoreNotFoundError) */ {
 public:
  StoreNotFoundError();
  virtual ~StoreNotFoundError();

  StoreNotFoundError(const StoreNotFoundError& from);

  inline StoreNotFoundError& operator=(const StoreNotFoundError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  StoreNotFoundError(StoreNotFoundError&& from) noexcept
    : StoreNotFoundError() {
    *this = ::std::move(from);
  }

  inline StoreNotFoundError& operator=(StoreNotFoundError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const StoreNotFoundError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const StoreNotFoundError* internal_default_instance() {
    return reinterpret_cast<const StoreNotFoundError*>(
               &_StoreNotFoundError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    20;

  void Swap(StoreNotFoundError* other);
  friend void swap(StoreNotFoundError& a, StoreNotFoundError& b) {
    a.Swap(&b);
  }

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

  inline StoreNotFoundError* New() const final {
    return CreateMaybeMessage<StoreNotFoundError>(NULL);
  }

  StoreNotFoundError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<StoreNotFoundError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const StoreNotFoundError& from);
  void MergeFrom(const StoreNotFoundError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(StoreNotFoundError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_store_id() const;
  void clear_store_id();
  static const int kStoreIdFieldNumber = 1;
  ::google::protobuf::int64 store_id() const;
  void set_store_id(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.StoreNotFoundError)
 private:
  void set_has_store_id();
  void clear_has_store_id();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int64 store_id_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class UnhandledRetryableError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.UnhandledRetryableError) */ {
 public:
  UnhandledRetryableError();
  virtual ~UnhandledRetryableError();

  UnhandledRetryableError(const UnhandledRetryableError& from);

  inline UnhandledRetryableError& operator=(const UnhandledRetryableError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  UnhandledRetryableError(UnhandledRetryableError&& from) noexcept
    : UnhandledRetryableError() {
    *this = ::std::move(from);
  }

  inline UnhandledRetryableError& operator=(UnhandledRetryableError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const UnhandledRetryableError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const UnhandledRetryableError* internal_default_instance() {
    return reinterpret_cast<const UnhandledRetryableError*>(
               &_UnhandledRetryableError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    21;

  void Swap(UnhandledRetryableError* other);
  friend void swap(UnhandledRetryableError& a, UnhandledRetryableError& b) {
    a.Swap(&b);
  }

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

  inline UnhandledRetryableError* New() const final {
    return CreateMaybeMessage<UnhandledRetryableError>(NULL);
  }

  UnhandledRetryableError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<UnhandledRetryableError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const UnhandledRetryableError& from);
  void MergeFrom(const UnhandledRetryableError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(UnhandledRetryableError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_perr() const;
  void clear_perr();
  static const int kPErrFieldNumber = 1;
  private:
  const ::cockroach::roachpb::Error& _internal_perr() const;
  public:
  const ::cockroach::roachpb::Error& perr() const;
  ::cockroach::roachpb::Error* release_perr();
  ::cockroach::roachpb::Error* mutable_perr();
  void set_allocated_perr(::cockroach::roachpb::Error* perr);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.UnhandledRetryableError)
 private:
  void set_has_perr();
  void clear_has_perr();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::cockroach::roachpb::Error* perr_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TransactionRetryWithProtoRefreshError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.TransactionRetryWithProtoRefreshError) */ {
 public:
  TransactionRetryWithProtoRefreshError();
  virtual ~TransactionRetryWithProtoRefreshError();

  TransactionRetryWithProtoRefreshError(const TransactionRetryWithProtoRefreshError& from);

  inline TransactionRetryWithProtoRefreshError& operator=(const TransactionRetryWithProtoRefreshError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TransactionRetryWithProtoRefreshError(TransactionRetryWithProtoRefreshError&& from) noexcept
    : TransactionRetryWithProtoRefreshError() {
    *this = ::std::move(from);
  }

  inline TransactionRetryWithProtoRefreshError& operator=(TransactionRetryWithProtoRefreshError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TransactionRetryWithProtoRefreshError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TransactionRetryWithProtoRefreshError* internal_default_instance() {
    return reinterpret_cast<const TransactionRetryWithProtoRefreshError*>(
               &_TransactionRetryWithProtoRefreshError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    22;

  void Swap(TransactionRetryWithProtoRefreshError* other);
  friend void swap(TransactionRetryWithProtoRefreshError& a, TransactionRetryWithProtoRefreshError& b) {
    a.Swap(&b);
  }

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

  inline TransactionRetryWithProtoRefreshError* New() const final {
    return CreateMaybeMessage<TransactionRetryWithProtoRefreshError>(NULL);
  }

  TransactionRetryWithProtoRefreshError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TransactionRetryWithProtoRefreshError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const TransactionRetryWithProtoRefreshError& from);
  void MergeFrom(const TransactionRetryWithProtoRefreshError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TransactionRetryWithProtoRefreshError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_msg() const;
  void clear_msg();
  static const int kMsgFieldNumber = 1;
  const ::std::string& msg() const;
  void set_msg(const ::std::string& value);
  #if LANG_CXX11
  void set_msg(::std::string&& value);
  #endif
  void set_msg(const char* value);
  void set_msg(const char* value, size_t size);
  ::std::string* mutable_msg();
  ::std::string* release_msg();
  void set_allocated_msg(::std::string* msg);

  bool has_txn_id() const;
  void clear_txn_id();
  static const int kTxnIdFieldNumber = 2;
  const ::std::string& txn_id() const;
  void set_txn_id(const ::std::string& value);
  #if LANG_CXX11
  void set_txn_id(::std::string&& value);
  #endif
  void set_txn_id(const char* value);
  void set_txn_id(const void* value, size_t size);
  ::std::string* mutable_txn_id();
  ::std::string* release_txn_id();
  void set_allocated_txn_id(::std::string* txn_id);

  bool has_transaction() const;
  void clear_transaction();
  static const int kTransactionFieldNumber = 3;
  private:
  const ::cockroach::roachpb::Transaction& _internal_transaction() const;
  public:
  const ::cockroach::roachpb::Transaction& transaction() const;
  ::cockroach::roachpb::Transaction* release_transaction();
  ::cockroach::roachpb::Transaction* mutable_transaction();
  void set_allocated_transaction(::cockroach::roachpb::Transaction* transaction);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.TransactionRetryWithProtoRefreshError)
 private:
  void set_has_msg();
  void clear_has_msg();
  void set_has_txn_id();
  void clear_has_txn_id();
  void set_has_transaction();
  void clear_has_transaction();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr msg_;
  ::google::protobuf::internal::ArenaStringPtr txn_id_;
  ::cockroach::roachpb::Transaction* transaction_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class TxnAlreadyEncounteredErrorError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.TxnAlreadyEncounteredErrorError) */ {
 public:
  TxnAlreadyEncounteredErrorError();
  virtual ~TxnAlreadyEncounteredErrorError();

  TxnAlreadyEncounteredErrorError(const TxnAlreadyEncounteredErrorError& from);

  inline TxnAlreadyEncounteredErrorError& operator=(const TxnAlreadyEncounteredErrorError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  TxnAlreadyEncounteredErrorError(TxnAlreadyEncounteredErrorError&& from) noexcept
    : TxnAlreadyEncounteredErrorError() {
    *this = ::std::move(from);
  }

  inline TxnAlreadyEncounteredErrorError& operator=(TxnAlreadyEncounteredErrorError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const TxnAlreadyEncounteredErrorError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TxnAlreadyEncounteredErrorError* internal_default_instance() {
    return reinterpret_cast<const TxnAlreadyEncounteredErrorError*>(
               &_TxnAlreadyEncounteredErrorError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    23;

  void Swap(TxnAlreadyEncounteredErrorError* other);
  friend void swap(TxnAlreadyEncounteredErrorError& a, TxnAlreadyEncounteredErrorError& b) {
    a.Swap(&b);
  }

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

  inline TxnAlreadyEncounteredErrorError* New() const final {
    return CreateMaybeMessage<TxnAlreadyEncounteredErrorError>(NULL);
  }

  TxnAlreadyEncounteredErrorError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<TxnAlreadyEncounteredErrorError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const TxnAlreadyEncounteredErrorError& from);
  void MergeFrom(const TxnAlreadyEncounteredErrorError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(TxnAlreadyEncounteredErrorError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_prev_error() const;
  void clear_prev_error();
  static const int kPrevErrorFieldNumber = 1;
  const ::std::string& prev_error() const;
  void set_prev_error(const ::std::string& value);
  #if LANG_CXX11
  void set_prev_error(::std::string&& value);
  #endif
  void set_prev_error(const char* value);
  void set_prev_error(const char* value, size_t size);
  ::std::string* mutable_prev_error();
  ::std::string* release_prev_error();
  void set_allocated_prev_error(::std::string* prev_error);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.TxnAlreadyEncounteredErrorError)
 private:
  void set_has_prev_error();
  void clear_has_prev_error();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr prev_error_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class IntegerOverflowError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.IntegerOverflowError) */ {
 public:
  IntegerOverflowError();
  virtual ~IntegerOverflowError();

  IntegerOverflowError(const IntegerOverflowError& from);

  inline IntegerOverflowError& operator=(const IntegerOverflowError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  IntegerOverflowError(IntegerOverflowError&& from) noexcept
    : IntegerOverflowError() {
    *this = ::std::move(from);
  }

  inline IntegerOverflowError& operator=(IntegerOverflowError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const IntegerOverflowError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const IntegerOverflowError* internal_default_instance() {
    return reinterpret_cast<const IntegerOverflowError*>(
               &_IntegerOverflowError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    24;

  void Swap(IntegerOverflowError* other);
  friend void swap(IntegerOverflowError& a, IntegerOverflowError& b) {
    a.Swap(&b);
  }

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

  inline IntegerOverflowError* New() const final {
    return CreateMaybeMessage<IntegerOverflowError>(NULL);
  }

  IntegerOverflowError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<IntegerOverflowError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const IntegerOverflowError& from);
  void MergeFrom(const IntegerOverflowError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(IntegerOverflowError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_key() const;
  void clear_key();
  static const int kKeyFieldNumber = 1;
  const ::std::string& key() const;
  void set_key(const ::std::string& value);
  #if LANG_CXX11
  void set_key(::std::string&& value);
  #endif
  void set_key(const char* value);
  void set_key(const void* value, size_t size);
  ::std::string* mutable_key();
  ::std::string* release_key();
  void set_allocated_key(::std::string* key);

  bool has_current_value() const;
  void clear_current_value();
  static const int kCurrentValueFieldNumber = 2;
  ::google::protobuf::int64 current_value() const;
  void set_current_value(::google::protobuf::int64 value);

  bool has_increment_value() const;
  void clear_increment_value();
  static const int kIncrementValueFieldNumber = 3;
  ::google::protobuf::int64 increment_value() const;
  void set_increment_value(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.IntegerOverflowError)
 private:
  void set_has_key();
  void clear_has_key();
  void set_has_current_value();
  void clear_has_current_value();
  void set_has_increment_value();
  void clear_has_increment_value();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr key_;
  ::google::protobuf::int64 current_value_;
  ::google::protobuf::int64 increment_value_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class BatchTimestampBeforeGCError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.BatchTimestampBeforeGCError) */ {
 public:
  BatchTimestampBeforeGCError();
  virtual ~BatchTimestampBeforeGCError();

  BatchTimestampBeforeGCError(const BatchTimestampBeforeGCError& from);

  inline BatchTimestampBeforeGCError& operator=(const BatchTimestampBeforeGCError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  BatchTimestampBeforeGCError(BatchTimestampBeforeGCError&& from) noexcept
    : BatchTimestampBeforeGCError() {
    *this = ::std::move(from);
  }

  inline BatchTimestampBeforeGCError& operator=(BatchTimestampBeforeGCError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const BatchTimestampBeforeGCError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const BatchTimestampBeforeGCError* internal_default_instance() {
    return reinterpret_cast<const BatchTimestampBeforeGCError*>(
               &_BatchTimestampBeforeGCError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    25;

  void Swap(BatchTimestampBeforeGCError* other);
  friend void swap(BatchTimestampBeforeGCError& a, BatchTimestampBeforeGCError& b) {
    a.Swap(&b);
  }

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

  inline BatchTimestampBeforeGCError* New() const final {
    return CreateMaybeMessage<BatchTimestampBeforeGCError>(NULL);
  }

  BatchTimestampBeforeGCError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<BatchTimestampBeforeGCError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const BatchTimestampBeforeGCError& from);
  void MergeFrom(const BatchTimestampBeforeGCError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(BatchTimestampBeforeGCError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_timestamp() const;
  void clear_timestamp();
  static const int kTimestampFieldNumber = 1;
  private:
  const ::cockroach::util::hlc::Timestamp& _internal_timestamp() const;
  public:
  const ::cockroach::util::hlc::Timestamp& timestamp() const;
  ::cockroach::util::hlc::Timestamp* release_timestamp();
  ::cockroach::util::hlc::Timestamp* mutable_timestamp();
  void set_allocated_timestamp(::cockroach::util::hlc::Timestamp* timestamp);

  bool has_threshold() const;
  void clear_threshold();
  static const int kThresholdFieldNumber = 2;
  private:
  const ::cockroach::util::hlc::Timestamp& _internal_threshold() const;
  public:
  const ::cockroach::util::hlc::Timestamp& threshold() const;
  ::cockroach::util::hlc::Timestamp* release_threshold();
  ::cockroach::util::hlc::Timestamp* mutable_threshold();
  void set_allocated_threshold(::cockroach::util::hlc::Timestamp* threshold);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.BatchTimestampBeforeGCError)
 private:
  void set_has_timestamp();
  void clear_has_timestamp();
  void set_has_threshold();
  void clear_has_threshold();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::cockroach::util::hlc::Timestamp* timestamp_;
  ::cockroach::util::hlc::Timestamp* threshold_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class IntentMissingError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.IntentMissingError) */ {
 public:
  IntentMissingError();
  virtual ~IntentMissingError();

  IntentMissingError(const IntentMissingError& from);

  inline IntentMissingError& operator=(const IntentMissingError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  IntentMissingError(IntentMissingError&& from) noexcept
    : IntentMissingError() {
    *this = ::std::move(from);
  }

  inline IntentMissingError& operator=(IntentMissingError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const IntentMissingError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const IntentMissingError* internal_default_instance() {
    return reinterpret_cast<const IntentMissingError*>(
               &_IntentMissingError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    26;

  void Swap(IntentMissingError* other);
  friend void swap(IntentMissingError& a, IntentMissingError& b) {
    a.Swap(&b);
  }

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

  inline IntentMissingError* New() const final {
    return CreateMaybeMessage<IntentMissingError>(NULL);
  }

  IntentMissingError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<IntentMissingError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const IntentMissingError& from);
  void MergeFrom(const IntentMissingError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(IntentMissingError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_key() const;
  void clear_key();
  static const int kKeyFieldNumber = 2;
  const ::std::string& key() const;
  void set_key(const ::std::string& value);
  #if LANG_CXX11
  void set_key(::std::string&& value);
  #endif
  void set_key(const char* value);
  void set_key(const void* value, size_t size);
  ::std::string* mutable_key();
  ::std::string* release_key();
  void set_allocated_key(::std::string* key);

  // optional .cockroach.roachpb.Intent wrong_intent = 1;
  bool has_wrong_intent() const;
  void clear_wrong_intent();
  static const int kWrongIntentFieldNumber = 1;
  private:
  const ::cockroach::roachpb::Intent& _internal_wrong_intent() const;
  public:
  const ::cockroach::roachpb::Intent& wrong_intent() const;
  ::cockroach::roachpb::Intent* release_wrong_intent();
  ::cockroach::roachpb::Intent* mutable_wrong_intent();
  void set_allocated_wrong_intent(::cockroach::roachpb::Intent* wrong_intent);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.IntentMissingError)
 private:
  void set_has_wrong_intent();
  void clear_has_wrong_intent();
  void set_has_key();
  void clear_has_key();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr key_;
  ::cockroach::roachpb::Intent* wrong_intent_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class MergeInProgressError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.MergeInProgressError) */ {
 public:
  MergeInProgressError();
  virtual ~MergeInProgressError();

  MergeInProgressError(const MergeInProgressError& from);

  inline MergeInProgressError& operator=(const MergeInProgressError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  MergeInProgressError(MergeInProgressError&& from) noexcept
    : MergeInProgressError() {
    *this = ::std::move(from);
  }

  inline MergeInProgressError& operator=(MergeInProgressError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const MergeInProgressError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const MergeInProgressError* internal_default_instance() {
    return reinterpret_cast<const MergeInProgressError*>(
               &_MergeInProgressError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    27;

  void Swap(MergeInProgressError* other);
  friend void swap(MergeInProgressError& a, MergeInProgressError& b) {
    a.Swap(&b);
  }

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

  inline MergeInProgressError* New() const final {
    return CreateMaybeMessage<MergeInProgressError>(NULL);
  }

  MergeInProgressError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<MergeInProgressError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const MergeInProgressError& from);
  void MergeFrom(const MergeInProgressError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(MergeInProgressError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.MergeInProgressError)
 private:

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class RangeFeedRetryError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.RangeFeedRetryError) */ {
 public:
  RangeFeedRetryError();
  virtual ~RangeFeedRetryError();

  RangeFeedRetryError(const RangeFeedRetryError& from);

  inline RangeFeedRetryError& operator=(const RangeFeedRetryError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  RangeFeedRetryError(RangeFeedRetryError&& from) noexcept
    : RangeFeedRetryError() {
    *this = ::std::move(from);
  }

  inline RangeFeedRetryError& operator=(RangeFeedRetryError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const RangeFeedRetryError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const RangeFeedRetryError* internal_default_instance() {
    return reinterpret_cast<const RangeFeedRetryError*>(
               &_RangeFeedRetryError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    28;

  void Swap(RangeFeedRetryError* other);
  friend void swap(RangeFeedRetryError& a, RangeFeedRetryError& b) {
    a.Swap(&b);
  }

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

  inline RangeFeedRetryError* New() const final {
    return CreateMaybeMessage<RangeFeedRetryError>(NULL);
  }

  RangeFeedRetryError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<RangeFeedRetryError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const RangeFeedRetryError& from);
  void MergeFrom(const RangeFeedRetryError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(RangeFeedRetryError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

  typedef RangeFeedRetryError_Reason Reason;
  static const Reason REASON_REPLICA_REMOVED =
    RangeFeedRetryError_Reason_REASON_REPLICA_REMOVED;
  static const Reason REASON_RANGE_SPLIT =
    RangeFeedRetryError_Reason_REASON_RANGE_SPLIT;
  static const Reason REASON_RANGE_MERGED =
    RangeFeedRetryError_Reason_REASON_RANGE_MERGED;
  static const Reason REASON_RAFT_SNAPSHOT =
    RangeFeedRetryError_Reason_REASON_RAFT_SNAPSHOT;
  static const Reason REASON_LOGICAL_OPS_MISSING =
    RangeFeedRetryError_Reason_REASON_LOGICAL_OPS_MISSING;
  static const Reason REASON_SLOW_CONSUMER =
    RangeFeedRetryError_Reason_REASON_SLOW_CONSUMER;
  static inline bool Reason_IsValid(int value) {
    return RangeFeedRetryError_Reason_IsValid(value);
  }
  static const Reason Reason_MIN =
    RangeFeedRetryError_Reason_Reason_MIN;
  static const Reason Reason_MAX =
    RangeFeedRetryError_Reason_Reason_MAX;
  static const int Reason_ARRAYSIZE =
    RangeFeedRetryError_Reason_Reason_ARRAYSIZE;

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

  bool has_reason() const;
  void clear_reason();
  static const int kReasonFieldNumber = 1;
  ::cockroach::roachpb::RangeFeedRetryError_Reason reason() const;
  void set_reason(::cockroach::roachpb::RangeFeedRetryError_Reason value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.RangeFeedRetryError)
 private:
  void set_has_reason();
  void clear_has_reason();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  int reason_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class IndeterminateCommitError : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.IndeterminateCommitError) */ {
 public:
  IndeterminateCommitError();
  virtual ~IndeterminateCommitError();

  IndeterminateCommitError(const IndeterminateCommitError& from);

  inline IndeterminateCommitError& operator=(const IndeterminateCommitError& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  IndeterminateCommitError(IndeterminateCommitError&& from) noexcept
    : IndeterminateCommitError() {
    *this = ::std::move(from);
  }

  inline IndeterminateCommitError& operator=(IndeterminateCommitError&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const IndeterminateCommitError& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const IndeterminateCommitError* internal_default_instance() {
    return reinterpret_cast<const IndeterminateCommitError*>(
               &_IndeterminateCommitError_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    29;

  void Swap(IndeterminateCommitError* other);
  friend void swap(IndeterminateCommitError& a, IndeterminateCommitError& b) {
    a.Swap(&b);
  }

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

  inline IndeterminateCommitError* New() const final {
    return CreateMaybeMessage<IndeterminateCommitError>(NULL);
  }

  IndeterminateCommitError* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<IndeterminateCommitError>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const IndeterminateCommitError& from);
  void MergeFrom(const IndeterminateCommitError& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(IndeterminateCommitError* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_staging_txn() const;
  void clear_staging_txn();
  static const int kStagingTxnFieldNumber = 1;
  private:
  const ::cockroach::roachpb::Transaction& _internal_staging_txn() const;
  public:
  const ::cockroach::roachpb::Transaction& staging_txn() const;
  ::cockroach::roachpb::Transaction* release_staging_txn();
  ::cockroach::roachpb::Transaction* mutable_staging_txn();
  void set_allocated_staging_txn(::cockroach::roachpb::Transaction* staging_txn);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.IndeterminateCommitError)
 private:
  void set_has_staging_txn();
  void clear_has_staging_txn();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::cockroach::roachpb::Transaction* staging_txn_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ErrorDetail : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.ErrorDetail) */ {
 public:
  ErrorDetail();
  virtual ~ErrorDetail();

  ErrorDetail(const ErrorDetail& from);

  inline ErrorDetail& operator=(const ErrorDetail& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ErrorDetail(ErrorDetail&& from) noexcept
    : ErrorDetail() {
    *this = ::std::move(from);
  }

  inline ErrorDetail& operator=(ErrorDetail&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ErrorDetail& default_instance();

  enum ValueCase {
    kNotLeaseHolder = 1,
    kRangeNotFound = 2,
    kRangeKeyMismatch = 3,
    kReadWithinUncertaintyInterval = 4,
    kTransactionAborted = 5,
    kTransactionPush = 6,
    kTransactionRetry = 7,
    kTransactionStatus = 8,
    kWriteIntent = 9,
    kWriteTooOld = 10,
    kOpRequiresTxn = 11,
    kConditionFailed = 12,
    kLeaseRejected = 13,
    kNodeUnavailable = 14,
    kSend = 15,
    kRaftGroupDeleted = 16,
    kReplicaCorruption = 17,
    kReplicaTooOld = 18,
    kAmbiguousResult = 26,
    kStoreNotFound = 27,
    kTransactionRetryWithProtoRefresh = 28,
    kIntegerOverflow = 31,
    kUnsupportedRequest = 32,
    kTimestampBefore = 34,
    kTxnAlreadyEncounteredError = 35,
    kIntentMissing = 36,
    kMergeInProgress = 37,
    kRangefeedRetry = 38,
    kIndeterminateCommit = 39,
    VALUE_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ErrorDetail* internal_default_instance() {
    return reinterpret_cast<const ErrorDetail*>(
               &_ErrorDetail_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    30;

  void Swap(ErrorDetail* other);
  friend void swap(ErrorDetail& a, ErrorDetail& b) {
    a.Swap(&b);
  }

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

  inline ErrorDetail* New() const final {
    return CreateMaybeMessage<ErrorDetail>(NULL);
  }

  ErrorDetail* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ErrorDetail>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const ErrorDetail& from);
  void MergeFrom(const ErrorDetail& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ErrorDetail* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  // optional .cockroach.roachpb.NotLeaseHolderError not_lease_holder = 1;
  bool has_not_lease_holder() const;
  void clear_not_lease_holder();
  static const int kNotLeaseHolderFieldNumber = 1;
  private:
  const ::cockroach::roachpb::NotLeaseHolderError& _internal_not_lease_holder() const;
  public:
  const ::cockroach::roachpb::NotLeaseHolderError& not_lease_holder() const;
  ::cockroach::roachpb::NotLeaseHolderError* release_not_lease_holder();
  ::cockroach::roachpb::NotLeaseHolderError* mutable_not_lease_holder();
  void set_allocated_not_lease_holder(::cockroach::roachpb::NotLeaseHolderError* not_lease_holder);

  // optional .cockroach.roachpb.RangeNotFoundError range_not_found = 2;
  bool has_range_not_found() const;
  void clear_range_not_found();
  static const int kRangeNotFoundFieldNumber = 2;
  private:
  const ::cockroach::roachpb::RangeNotFoundError& _internal_range_not_found() const;
  public:
  const ::cockroach::roachpb::RangeNotFoundError& range_not_found() const;
  ::cockroach::roachpb::RangeNotFoundError* release_range_not_found();
  ::cockroach::roachpb::RangeNotFoundError* mutable_range_not_found();
  void set_allocated_range_not_found(::cockroach::roachpb::RangeNotFoundError* range_not_found);

  // optional .cockroach.roachpb.RangeKeyMismatchError range_key_mismatch = 3;
  bool has_range_key_mismatch() const;
  void clear_range_key_mismatch();
  static const int kRangeKeyMismatchFieldNumber = 3;
  private:
  const ::cockroach::roachpb::RangeKeyMismatchError& _internal_range_key_mismatch() const;
  public:
  const ::cockroach::roachpb::RangeKeyMismatchError& range_key_mismatch() const;
  ::cockroach::roachpb::RangeKeyMismatchError* release_range_key_mismatch();
  ::cockroach::roachpb::RangeKeyMismatchError* mutable_range_key_mismatch();
  void set_allocated_range_key_mismatch(::cockroach::roachpb::RangeKeyMismatchError* range_key_mismatch);

  // optional .cockroach.roachpb.ReadWithinUncertaintyIntervalError read_within_uncertainty_interval = 4;
  bool has_read_within_uncertainty_interval() const;
  void clear_read_within_uncertainty_interval();
  static const int kReadWithinUncertaintyIntervalFieldNumber = 4;
  private:
  const ::cockroach::roachpb::ReadWithinUncertaintyIntervalError& _internal_read_within_uncertainty_interval() const;
  public:
  const ::cockroach::roachpb::ReadWithinUncertaintyIntervalError& read_within_uncertainty_interval() const;
  ::cockroach::roachpb::ReadWithinUncertaintyIntervalError* release_read_within_uncertainty_interval();
  ::cockroach::roachpb::ReadWithinUncertaintyIntervalError* mutable_read_within_uncertainty_interval();
  void set_allocated_read_within_uncertainty_interval(::cockroach::roachpb::ReadWithinUncertaintyIntervalError* read_within_uncertainty_interval);

  // optional .cockroach.roachpb.TransactionAbortedError transaction_aborted = 5;
  bool has_transaction_aborted() const;
  void clear_transaction_aborted();
  static const int kTransactionAbortedFieldNumber = 5;
  private:
  const ::cockroach::roachpb::TransactionAbortedError& _internal_transaction_aborted() const;
  public:
  const ::cockroach::roachpb::TransactionAbortedError& transaction_aborted() const;
  ::cockroach::roachpb::TransactionAbortedError* release_transaction_aborted();
  ::cockroach::roachpb::TransactionAbortedError* mutable_transaction_aborted();
  void set_allocated_transaction_aborted(::cockroach::roachpb::TransactionAbortedError* transaction_aborted);

  // optional .cockroach.roachpb.TransactionPushError transaction_push = 6;
  bool has_transaction_push() const;
  void clear_transaction_push();
  static const int kTransactionPushFieldNumber = 6;
  private:
  const ::cockroach::roachpb::TransactionPushError& _internal_transaction_push() const;
  public:
  const ::cockroach::roachpb::TransactionPushError& transaction_push() const;
  ::cockroach::roachpb::TransactionPushError* release_transaction_push();
  ::cockroach::roachpb::TransactionPushError* mutable_transaction_push();
  void set_allocated_transaction_push(::cockroach::roachpb::TransactionPushError* transaction_push);

  // optional .cockroach.roachpb.TransactionRetryError transaction_retry = 7;
  bool has_transaction_retry() const;
  void clear_transaction_retry();
  static const int kTransactionRetryFieldNumber = 7;
  private:
  const ::cockroach::roachpb::TransactionRetryError& _internal_transaction_retry() const;
  public:
  const ::cockroach::roachpb::TransactionRetryError& transaction_retry() const;
  ::cockroach::roachpb::TransactionRetryError* release_transaction_retry();
  ::cockroach::roachpb::TransactionRetryError* mutable_transaction_retry();
  void set_allocated_transaction_retry(::cockroach::roachpb::TransactionRetryError* transaction_retry);

  // optional .cockroach.roachpb.TransactionStatusError transaction_status = 8;
  bool has_transaction_status() const;
  void clear_transaction_status();
  static const int kTransactionStatusFieldNumber = 8;
  private:
  const ::cockroach::roachpb::TransactionStatusError& _internal_transaction_status() const;
  public:
  const ::cockroach::roachpb::TransactionStatusError& transaction_status() const;
  ::cockroach::roachpb::TransactionStatusError* release_transaction_status();
  ::cockroach::roachpb::TransactionStatusError* mutable_transaction_status();
  void set_allocated_transaction_status(::cockroach::roachpb::TransactionStatusError* transaction_status);

  // optional .cockroach.roachpb.WriteIntentError write_intent = 9;
  bool has_write_intent() const;
  void clear_write_intent();
  static const int kWriteIntentFieldNumber = 9;
  private:
  const ::cockroach::roachpb::WriteIntentError& _internal_write_intent() const;
  public:
  const ::cockroach::roachpb::WriteIntentError& write_intent() const;
  ::cockroach::roachpb::WriteIntentError* release_write_intent();
  ::cockroach::roachpb::WriteIntentError* mutable_write_intent();
  void set_allocated_write_intent(::cockroach::roachpb::WriteIntentError* write_intent);

  // optional .cockroach.roachpb.WriteTooOldError write_too_old = 10;
  bool has_write_too_old() const;
  void clear_write_too_old();
  static const int kWriteTooOldFieldNumber = 10;
  private:
  const ::cockroach::roachpb::WriteTooOldError& _internal_write_too_old() const;
  public:
  const ::cockroach::roachpb::WriteTooOldError& write_too_old() const;
  ::cockroach::roachpb::WriteTooOldError* release_write_too_old();
  ::cockroach::roachpb::WriteTooOldError* mutable_write_too_old();
  void set_allocated_write_too_old(::cockroach::roachpb::WriteTooOldError* write_too_old);

  // optional .cockroach.roachpb.OpRequiresTxnError op_requires_txn = 11;
  bool has_op_requires_txn() const;
  void clear_op_requires_txn();
  static const int kOpRequiresTxnFieldNumber = 11;
  private:
  const ::cockroach::roachpb::OpRequiresTxnError& _internal_op_requires_txn() const;
  public:
  const ::cockroach::roachpb::OpRequiresTxnError& op_requires_txn() const;
  ::cockroach::roachpb::OpRequiresTxnError* release_op_requires_txn();
  ::cockroach::roachpb::OpRequiresTxnError* mutable_op_requires_txn();
  void set_allocated_op_requires_txn(::cockroach::roachpb::OpRequiresTxnError* op_requires_txn);

  // optional .cockroach.roachpb.ConditionFailedError condition_failed = 12;
  bool has_condition_failed() const;
  void clear_condition_failed();
  static const int kConditionFailedFieldNumber = 12;
  private:
  const ::cockroach::roachpb::ConditionFailedError& _internal_condition_failed() const;
  public:
  const ::cockroach::roachpb::ConditionFailedError& condition_failed() const;
  ::cockroach::roachpb::ConditionFailedError* release_condition_failed();
  ::cockroach::roachpb::ConditionFailedError* mutable_condition_failed();
  void set_allocated_condition_failed(::cockroach::roachpb::ConditionFailedError* condition_failed);

  // optional .cockroach.roachpb.LeaseRejectedError lease_rejected = 13;
  bool has_lease_rejected() const;
  void clear_lease_rejected();
  static const int kLeaseRejectedFieldNumber = 13;
  private:
  const ::cockroach::roachpb::LeaseRejectedError& _internal_lease_rejected() const;
  public:
  const ::cockroach::roachpb::LeaseRejectedError& lease_rejected() const;
  ::cockroach::roachpb::LeaseRejectedError* release_lease_rejected();
  ::cockroach::roachpb::LeaseRejectedError* mutable_lease_rejected();
  void set_allocated_lease_rejected(::cockroach::roachpb::LeaseRejectedError* lease_rejected);

  // optional .cockroach.roachpb.NodeUnavailableError node_unavailable = 14;
  bool has_node_unavailable() const;
  void clear_node_unavailable();
  static const int kNodeUnavailableFieldNumber = 14;
  private:
  const ::cockroach::roachpb::NodeUnavailableError& _internal_node_unavailable() const;
  public:
  const ::cockroach::roachpb::NodeUnavailableError& node_unavailable() const;
  ::cockroach::roachpb::NodeUnavailableError* release_node_unavailable();
  ::cockroach::roachpb::NodeUnavailableError* mutable_node_unavailable();
  void set_allocated_node_unavailable(::cockroach::roachpb::NodeUnavailableError* node_unavailable);

  // optional .cockroach.roachpb.SendError send = 15;
  bool has_send() const;
  void clear_send();
  static const int kSendFieldNumber = 15;
  private:
  const ::cockroach::roachpb::SendError& _internal_send() const;
  public:
  const ::cockroach::roachpb::SendError& send() const;
  ::cockroach::roachpb::SendError* release_send();
  ::cockroach::roachpb::SendError* mutable_send();
  void set_allocated_send(::cockroach::roachpb::SendError* send);

  // optional .cockroach.roachpb.RaftGroupDeletedError raft_group_deleted = 16;
  bool has_raft_group_deleted() const;
  void clear_raft_group_deleted();
  static const int kRaftGroupDeletedFieldNumber = 16;
  private:
  const ::cockroach::roachpb::RaftGroupDeletedError& _internal_raft_group_deleted() const;
  public:
  const ::cockroach::roachpb::RaftGroupDeletedError& raft_group_deleted() const;
  ::cockroach::roachpb::RaftGroupDeletedError* release_raft_group_deleted();
  ::cockroach::roachpb::RaftGroupDeletedError* mutable_raft_group_deleted();
  void set_allocated_raft_group_deleted(::cockroach::roachpb::RaftGroupDeletedError* raft_group_deleted);

  // optional .cockroach.roachpb.ReplicaCorruptionError replica_corruption = 17;
  bool has_replica_corruption() const;
  void clear_replica_corruption();
  static const int kReplicaCorruptionFieldNumber = 17;
  private:
  const ::cockroach::roachpb::ReplicaCorruptionError& _internal_replica_corruption() const;
  public:
  const ::cockroach::roachpb::ReplicaCorruptionError& replica_corruption() const;
  ::cockroach::roachpb::ReplicaCorruptionError* release_replica_corruption();
  ::cockroach::roachpb::ReplicaCorruptionError* mutable_replica_corruption();
  void set_allocated_replica_corruption(::cockroach::roachpb::ReplicaCorruptionError* replica_corruption);

  // optional .cockroach.roachpb.ReplicaTooOldError replica_too_old = 18;
  bool has_replica_too_old() const;
  void clear_replica_too_old();
  static const int kReplicaTooOldFieldNumber = 18;
  private:
  const ::cockroach::roachpb::ReplicaTooOldError& _internal_replica_too_old() const;
  public:
  const ::cockroach::roachpb::ReplicaTooOldError& replica_too_old() const;
  ::cockroach::roachpb::ReplicaTooOldError* release_replica_too_old();
  ::cockroach::roachpb::ReplicaTooOldError* mutable_replica_too_old();
  void set_allocated_replica_too_old(::cockroach::roachpb::ReplicaTooOldError* replica_too_old);

  // optional .cockroach.roachpb.AmbiguousResultError ambiguous_result = 26;
  bool has_ambiguous_result() const;
  void clear_ambiguous_result();
  static const int kAmbiguousResultFieldNumber = 26;
  private:
  const ::cockroach::roachpb::AmbiguousResultError& _internal_ambiguous_result() const;
  public:
  const ::cockroach::roachpb::AmbiguousResultError& ambiguous_result() const;
  ::cockroach::roachpb::AmbiguousResultError* release_ambiguous_result();
  ::cockroach::roachpb::AmbiguousResultError* mutable_ambiguous_result();
  void set_allocated_ambiguous_result(::cockroach::roachpb::AmbiguousResultError* ambiguous_result);

  // optional .cockroach.roachpb.StoreNotFoundError store_not_found = 27;
  bool has_store_not_found() const;
  void clear_store_not_found();
  static const int kStoreNotFoundFieldNumber = 27;
  private:
  const ::cockroach::roachpb::StoreNotFoundError& _internal_store_not_found() const;
  public:
  const ::cockroach::roachpb::StoreNotFoundError& store_not_found() const;
  ::cockroach::roachpb::StoreNotFoundError* release_store_not_found();
  ::cockroach::roachpb::StoreNotFoundError* mutable_store_not_found();
  void set_allocated_store_not_found(::cockroach::roachpb::StoreNotFoundError* store_not_found);

  // optional .cockroach.roachpb.TransactionRetryWithProtoRefreshError transaction_retry_with_proto_refresh = 28;
  bool has_transaction_retry_with_proto_refresh() const;
  void clear_transaction_retry_with_proto_refresh();
  static const int kTransactionRetryWithProtoRefreshFieldNumber = 28;
  private:
  const ::cockroach::roachpb::TransactionRetryWithProtoRefreshError& _internal_transaction_retry_with_proto_refresh() const;
  public:
  const ::cockroach::roachpb::TransactionRetryWithProtoRefreshError& transaction_retry_with_proto_refresh() const;
  ::cockroach::roachpb::TransactionRetryWithProtoRefreshError* release_transaction_retry_with_proto_refresh();
  ::cockroach::roachpb::TransactionRetryWithProtoRefreshError* mutable_transaction_retry_with_proto_refresh();
  void set_allocated_transaction_retry_with_proto_refresh(::cockroach::roachpb::TransactionRetryWithProtoRefreshError* transaction_retry_with_proto_refresh);

  // optional .cockroach.roachpb.IntegerOverflowError integer_overflow = 31;
  bool has_integer_overflow() const;
  void clear_integer_overflow();
  static const int kIntegerOverflowFieldNumber = 31;
  private:
  const ::cockroach::roachpb::IntegerOverflowError& _internal_integer_overflow() const;
  public:
  const ::cockroach::roachpb::IntegerOverflowError& integer_overflow() const;
  ::cockroach::roachpb::IntegerOverflowError* release_integer_overflow();
  ::cockroach::roachpb::IntegerOverflowError* mutable_integer_overflow();
  void set_allocated_integer_overflow(::cockroach::roachpb::IntegerOverflowError* integer_overflow);

  // optional .cockroach.roachpb.UnsupportedRequestError unsupported_request = 32;
  bool has_unsupported_request() const;
  void clear_unsupported_request();
  static const int kUnsupportedRequestFieldNumber = 32;
  private:
  const ::cockroach::roachpb::UnsupportedRequestError& _internal_unsupported_request() const;
  public:
  const ::cockroach::roachpb::UnsupportedRequestError& unsupported_request() const;
  ::cockroach::roachpb::UnsupportedRequestError* release_unsupported_request();
  ::cockroach::roachpb::UnsupportedRequestError* mutable_unsupported_request();
  void set_allocated_unsupported_request(::cockroach::roachpb::UnsupportedRequestError* unsupported_request);

  // optional .cockroach.roachpb.BatchTimestampBeforeGCError timestamp_before = 34;
  bool has_timestamp_before() const;
  void clear_timestamp_before();
  static const int kTimestampBeforeFieldNumber = 34;
  private:
  const ::cockroach::roachpb::BatchTimestampBeforeGCError& _internal_timestamp_before() const;
  public:
  const ::cockroach::roachpb::BatchTimestampBeforeGCError& timestamp_before() const;
  ::cockroach::roachpb::BatchTimestampBeforeGCError* release_timestamp_before();
  ::cockroach::roachpb::BatchTimestampBeforeGCError* mutable_timestamp_before();
  void set_allocated_timestamp_before(::cockroach::roachpb::BatchTimestampBeforeGCError* timestamp_before);

  // optional .cockroach.roachpb.TxnAlreadyEncounteredErrorError txn_already_encountered_error = 35;
  bool has_txn_already_encountered_error() const;
  void clear_txn_already_encountered_error();
  static const int kTxnAlreadyEncounteredErrorFieldNumber = 35;
  private:
  const ::cockroach::roachpb::TxnAlreadyEncounteredErrorError& _internal_txn_already_encountered_error() const;
  public:
  const ::cockroach::roachpb::TxnAlreadyEncounteredErrorError& txn_already_encountered_error() const;
  ::cockroach::roachpb::TxnAlreadyEncounteredErrorError* release_txn_already_encountered_error();
  ::cockroach::roachpb::TxnAlreadyEncounteredErrorError* mutable_txn_already_encountered_error();
  void set_allocated_txn_already_encountered_error(::cockroach::roachpb::TxnAlreadyEncounteredErrorError* txn_already_encountered_error);

  // optional .cockroach.roachpb.IntentMissingError intent_missing = 36;
  bool has_intent_missing() const;
  void clear_intent_missing();
  static const int kIntentMissingFieldNumber = 36;
  private:
  const ::cockroach::roachpb::IntentMissingError& _internal_intent_missing() const;
  public:
  const ::cockroach::roachpb::IntentMissingError& intent_missing() const;
  ::cockroach::roachpb::IntentMissingError* release_intent_missing();
  ::cockroach::roachpb::IntentMissingError* mutable_intent_missing();
  void set_allocated_intent_missing(::cockroach::roachpb::IntentMissingError* intent_missing);

  // optional .cockroach.roachpb.MergeInProgressError merge_in_progress = 37;
  bool has_merge_in_progress() const;
  void clear_merge_in_progress();
  static const int kMergeInProgressFieldNumber = 37;
  private:
  const ::cockroach::roachpb::MergeInProgressError& _internal_merge_in_progress() const;
  public:
  const ::cockroach::roachpb::MergeInProgressError& merge_in_progress() const;
  ::cockroach::roachpb::MergeInProgressError* release_merge_in_progress();
  ::cockroach::roachpb::MergeInProgressError* mutable_merge_in_progress();
  void set_allocated_merge_in_progress(::cockroach::roachpb::MergeInProgressError* merge_in_progress);

  // optional .cockroach.roachpb.RangeFeedRetryError rangefeed_retry = 38;
  bool has_rangefeed_retry() const;
  void clear_rangefeed_retry();
  static const int kRangefeedRetryFieldNumber = 38;
  private:
  const ::cockroach::roachpb::RangeFeedRetryError& _internal_rangefeed_retry() const;
  public:
  const ::cockroach::roachpb::RangeFeedRetryError& rangefeed_retry() const;
  ::cockroach::roachpb::RangeFeedRetryError* release_rangefeed_retry();
  ::cockroach::roachpb::RangeFeedRetryError* mutable_rangefeed_retry();
  void set_allocated_rangefeed_retry(::cockroach::roachpb::RangeFeedRetryError* rangefeed_retry);

  // optional .cockroach.roachpb.IndeterminateCommitError indeterminate_commit = 39;
  bool has_indeterminate_commit() const;
  void clear_indeterminate_commit();
  static const int kIndeterminateCommitFieldNumber = 39;
  private:
  const ::cockroach::roachpb::IndeterminateCommitError& _internal_indeterminate_commit() const;
  public:
  const ::cockroach::roachpb::IndeterminateCommitError& indeterminate_commit() const;
  ::cockroach::roachpb::IndeterminateCommitError* release_indeterminate_commit();
  ::cockroach::roachpb::IndeterminateCommitError* mutable_indeterminate_commit();
  void set_allocated_indeterminate_commit(::cockroach::roachpb::IndeterminateCommitError* indeterminate_commit);

  void clear_value();
  ValueCase value_case() const;
  // @@protoc_insertion_point(class_scope:cockroach.roachpb.ErrorDetail)
 private:
  void set_has_not_lease_holder();
  void set_has_range_not_found();
  void set_has_range_key_mismatch();
  void set_has_read_within_uncertainty_interval();
  void set_has_transaction_aborted();
  void set_has_transaction_push();
  void set_has_transaction_retry();
  void set_has_transaction_status();
  void set_has_write_intent();
  void set_has_write_too_old();
  void set_has_op_requires_txn();
  void set_has_condition_failed();
  void set_has_lease_rejected();
  void set_has_node_unavailable();
  void set_has_send();
  void set_has_raft_group_deleted();
  void set_has_replica_corruption();
  void set_has_replica_too_old();
  void set_has_ambiguous_result();
  void set_has_store_not_found();
  void set_has_transaction_retry_with_proto_refresh();
  void set_has_integer_overflow();
  void set_has_unsupported_request();
  void set_has_timestamp_before();
  void set_has_txn_already_encountered_error();
  void set_has_intent_missing();
  void set_has_merge_in_progress();
  void set_has_rangefeed_retry();
  void set_has_indeterminate_commit();

  inline bool has_value() const;
  inline void clear_has_value();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  union ValueUnion {
    ValueUnion() {}
    ::cockroach::roachpb::NotLeaseHolderError* not_lease_holder_;
    ::cockroach::roachpb::RangeNotFoundError* range_not_found_;
    ::cockroach::roachpb::RangeKeyMismatchError* range_key_mismatch_;
    ::cockroach::roachpb::ReadWithinUncertaintyIntervalError* read_within_uncertainty_interval_;
    ::cockroach::roachpb::TransactionAbortedError* transaction_aborted_;
    ::cockroach::roachpb::TransactionPushError* transaction_push_;
    ::cockroach::roachpb::TransactionRetryError* transaction_retry_;
    ::cockroach::roachpb::TransactionStatusError* transaction_status_;
    ::cockroach::roachpb::WriteIntentError* write_intent_;
    ::cockroach::roachpb::WriteTooOldError* write_too_old_;
    ::cockroach::roachpb::OpRequiresTxnError* op_requires_txn_;
    ::cockroach::roachpb::ConditionFailedError* condition_failed_;
    ::cockroach::roachpb::LeaseRejectedError* lease_rejected_;
    ::cockroach::roachpb::NodeUnavailableError* node_unavailable_;
    ::cockroach::roachpb::SendError* send_;
    ::cockroach::roachpb::RaftGroupDeletedError* raft_group_deleted_;
    ::cockroach::roachpb::ReplicaCorruptionError* replica_corruption_;
    ::cockroach::roachpb::ReplicaTooOldError* replica_too_old_;
    ::cockroach::roachpb::AmbiguousResultError* ambiguous_result_;
    ::cockroach::roachpb::StoreNotFoundError* store_not_found_;
    ::cockroach::roachpb::TransactionRetryWithProtoRefreshError* transaction_retry_with_proto_refresh_;
    ::cockroach::roachpb::IntegerOverflowError* integer_overflow_;
    ::cockroach::roachpb::UnsupportedRequestError* unsupported_request_;
    ::cockroach::roachpb::BatchTimestampBeforeGCError* timestamp_before_;
    ::cockroach::roachpb::TxnAlreadyEncounteredErrorError* txn_already_encountered_error_;
    ::cockroach::roachpb::IntentMissingError* intent_missing_;
    ::cockroach::roachpb::MergeInProgressError* merge_in_progress_;
    ::cockroach::roachpb::RangeFeedRetryError* rangefeed_retry_;
    ::cockroach::roachpb::IndeterminateCommitError* indeterminate_commit_;
  } value_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ErrPosition : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.ErrPosition) */ {
 public:
  ErrPosition();
  virtual ~ErrPosition();

  ErrPosition(const ErrPosition& from);

  inline ErrPosition& operator=(const ErrPosition& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ErrPosition(ErrPosition&& from) noexcept
    : ErrPosition() {
    *this = ::std::move(from);
  }

  inline ErrPosition& operator=(ErrPosition&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ErrPosition& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ErrPosition* internal_default_instance() {
    return reinterpret_cast<const ErrPosition*>(
               &_ErrPosition_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    31;

  void Swap(ErrPosition* other);
  friend void swap(ErrPosition& a, ErrPosition& b) {
    a.Swap(&b);
  }

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

  inline ErrPosition* New() const final {
    return CreateMaybeMessage<ErrPosition>(NULL);
  }

  ErrPosition* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<ErrPosition>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const ErrPosition& from);
  void MergeFrom(const ErrPosition& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ErrPosition* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_index() const;
  void clear_index();
  static const int kIndexFieldNumber = 1;
  ::google::protobuf::int32 index() const;
  void set_index(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.ErrPosition)
 private:
  void set_has_index();
  void clear_has_index();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::int32 index_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Error : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:cockroach.roachpb.Error) */ {
 public:
  Error();
  virtual ~Error();

  Error(const Error& from);

  inline Error& operator=(const Error& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Error(Error&& from) noexcept
    : Error() {
    *this = ::std::move(from);
  }

  inline Error& operator=(Error&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }
  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const Error& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Error* internal_default_instance() {
    return reinterpret_cast<const Error*>(
               &_Error_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    32;

  void Swap(Error* other);
  friend void swap(Error& a, Error& b) {
    a.Swap(&b);
  }

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

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

  Error* New(::google::protobuf::Arena* arena) const final {
    return CreateMaybeMessage<Error>(arena);
  }
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    final;
  void CopyFrom(const Error& from);
  void MergeFrom(const Error& from);
  void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) final;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Error* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const final;

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

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

  bool has_message() const;
  void clear_message();
  static const int kMessageFieldNumber = 1;
  const ::std::string& message() const;
  void set_message(const ::std::string& value);
  #if LANG_CXX11
  void set_message(::std::string&& value);
  #endif
  void set_message(const char* value);
  void set_message(const char* value, size_t size);
  ::std::string* mutable_message();
  ::std::string* release_message();
  void set_allocated_message(::std::string* message);

  // optional .cockroach.roachpb.Transaction unexposed_txn = 4;
  bool has_unexposed_txn() const;
  void clear_unexposed_txn();
  static const int kUnexposedTxnFieldNumber = 4;
  private:
  const ::cockroach::roachpb::Transaction& _internal_unexposed_txn() const;
  public:
  const ::cockroach::roachpb::Transaction& unexposed_txn() const;
  ::cockroach::roachpb::Transaction* release_unexposed_txn();
  ::cockroach::roachpb::Transaction* mutable_unexposed_txn();
  void set_allocated_unexposed_txn(::cockroach::roachpb::Transaction* unexposed_txn);

  bool has_detail() const;
  void clear_detail();
  static const int kDetailFieldNumber = 6;
  private:
  const ::cockroach::roachpb::ErrorDetail& _internal_detail() const;
  public:
  const ::cockroach::roachpb::ErrorDetail& detail() const;
  ::cockroach::roachpb::ErrorDetail* release_detail();
  ::cockroach::roachpb::ErrorDetail* mutable_detail();
  void set_allocated_detail(::cockroach::roachpb::ErrorDetail* detail);

  // optional .cockroach.roachpb.ErrPosition index = 7;
  bool has_index() const;
  void clear_index();
  static const int kIndexFieldNumber = 7;
  private:
  const ::cockroach::roachpb::ErrPosition& _internal_index() const;
  public:
  const ::cockroach::roachpb::ErrPosition& index() const;
  ::cockroach::roachpb::ErrPosition* release_index();
  ::cockroach::roachpb::ErrPosition* mutable_index();
  void set_allocated_index(::cockroach::roachpb::ErrPosition* index);

  bool has_now() const;
  void clear_now();
  static const int kNowFieldNumber = 8;
  private:
  const ::cockroach::util::hlc::Timestamp& _internal_now() const;
  public:
  const ::cockroach::util::hlc::Timestamp& now() const;
  ::cockroach::util::hlc::Timestamp* release_now();
  ::cockroach::util::hlc::Timestamp* mutable_now();
  void set_allocated_now(::cockroach::util::hlc::Timestamp* now);

  bool has_transaction_restart() const;
  void clear_transaction_restart();
  static const int kTransactionRestartFieldNumber = 3;
  ::cockroach::roachpb::TransactionRestart transaction_restart() const;
  void set_transaction_restart(::cockroach::roachpb::TransactionRestart value);

  bool has_origin_node() const;
  void clear_origin_node();
  static const int kOriginNodeFieldNumber = 5;
  ::google::protobuf::int32 origin_node() const;
  void set_origin_node(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:cockroach.roachpb.Error)
 private:
  void set_has_message();
  void clear_has_message();
  void set_has_transaction_restart();
  void clear_has_transaction_restart();
  void set_has_unexposed_txn();
  void clear_has_unexposed_txn();
  void set_has_origin_node();
  void clear_has_origin_node();
  void set_has_detail();
  void clear_has_detail();
  void set_has_index();
  void clear_has_index();
  void set_has_now();
  void clear_has_now();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable ::google::protobuf::internal::CachedSize _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr message_;
  ::cockroach::roachpb::Transaction* unexposed_txn_;
  ::cockroach::roachpb::ErrorDetail* detail_;
  ::cockroach::roachpb::ErrPosition* index_;
  ::cockroach::util::hlc::Timestamp* now_;
  int transaction_restart_;
  ::google::protobuf::int32 origin_node_;
  friend struct ::protobuf_roachpb_2ferrors_2eproto::TableStruct;
};
// ===================================================================


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

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

inline bool NotLeaseHolderError::has_replica() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void NotLeaseHolderError::set_has_replica() {
  _has_bits_[0] |= 0x00000002u;
}
inline void NotLeaseHolderError::clear_has_replica() {
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::cockroach::roachpb::ReplicaDescriptor& NotLeaseHolderError::_internal_replica() const {
  return *replica_;
}
inline const ::cockroach::roachpb::ReplicaDescriptor& NotLeaseHolderError::replica() const {
  const ::cockroach::roachpb::ReplicaDescriptor* p = replica_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.NotLeaseHolderError.replica)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::ReplicaDescriptor*>(
      &::cockroach::roachpb::_ReplicaDescriptor_default_instance_);
}
inline ::cockroach::roachpb::ReplicaDescriptor* NotLeaseHolderError::release_replica() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.NotLeaseHolderError.replica)
  clear_has_replica();
  ::cockroach::roachpb::ReplicaDescriptor* temp = replica_;
  replica_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::ReplicaDescriptor* NotLeaseHolderError::mutable_replica() {
  set_has_replica();
  if (replica_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::ReplicaDescriptor>(GetArenaNoVirtual());
    replica_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.NotLeaseHolderError.replica)
  return replica_;
}
inline void NotLeaseHolderError::set_allocated_replica(::cockroach::roachpb::ReplicaDescriptor* replica) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(replica_);
  }
  if (replica) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      replica = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, replica, submessage_arena);
    }
    set_has_replica();
  } else {
    clear_has_replica();
  }
  replica_ = replica;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.NotLeaseHolderError.replica)
}

// optional .cockroach.roachpb.ReplicaDescriptor lease_holder = 2;
inline bool NotLeaseHolderError::has_lease_holder() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void NotLeaseHolderError::set_has_lease_holder() {
  _has_bits_[0] |= 0x00000004u;
}
inline void NotLeaseHolderError::clear_has_lease_holder() {
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::cockroach::roachpb::ReplicaDescriptor& NotLeaseHolderError::_internal_lease_holder() const {
  return *lease_holder_;
}
inline const ::cockroach::roachpb::ReplicaDescriptor& NotLeaseHolderError::lease_holder() const {
  const ::cockroach::roachpb::ReplicaDescriptor* p = lease_holder_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.NotLeaseHolderError.lease_holder)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::ReplicaDescriptor*>(
      &::cockroach::roachpb::_ReplicaDescriptor_default_instance_);
}
inline ::cockroach::roachpb::ReplicaDescriptor* NotLeaseHolderError::release_lease_holder() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.NotLeaseHolderError.lease_holder)
  clear_has_lease_holder();
  ::cockroach::roachpb::ReplicaDescriptor* temp = lease_holder_;
  lease_holder_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::ReplicaDescriptor* NotLeaseHolderError::mutable_lease_holder() {
  set_has_lease_holder();
  if (lease_holder_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::ReplicaDescriptor>(GetArenaNoVirtual());
    lease_holder_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.NotLeaseHolderError.lease_holder)
  return lease_holder_;
}
inline void NotLeaseHolderError::set_allocated_lease_holder(::cockroach::roachpb::ReplicaDescriptor* lease_holder) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(lease_holder_);
  }
  if (lease_holder) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      lease_holder = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, lease_holder, submessage_arena);
    }
    set_has_lease_holder();
  } else {
    clear_has_lease_holder();
  }
  lease_holder_ = lease_holder;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.NotLeaseHolderError.lease_holder)
}

// optional .cockroach.roachpb.Lease lease = 4;
inline bool NotLeaseHolderError::has_lease() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void NotLeaseHolderError::set_has_lease() {
  _has_bits_[0] |= 0x00000008u;
}
inline void NotLeaseHolderError::clear_has_lease() {
  _has_bits_[0] &= ~0x00000008u;
}
inline const ::cockroach::roachpb::Lease& NotLeaseHolderError::_internal_lease() const {
  return *lease_;
}
inline const ::cockroach::roachpb::Lease& NotLeaseHolderError::lease() const {
  const ::cockroach::roachpb::Lease* p = lease_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.NotLeaseHolderError.lease)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Lease*>(
      &::cockroach::roachpb::_Lease_default_instance_);
}
inline ::cockroach::roachpb::Lease* NotLeaseHolderError::release_lease() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.NotLeaseHolderError.lease)
  clear_has_lease();
  ::cockroach::roachpb::Lease* temp = lease_;
  lease_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Lease* NotLeaseHolderError::mutable_lease() {
  set_has_lease();
  if (lease_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Lease>(GetArenaNoVirtual());
    lease_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.NotLeaseHolderError.lease)
  return lease_;
}
inline void NotLeaseHolderError::set_allocated_lease(::cockroach::roachpb::Lease* lease) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(lease_);
  }
  if (lease) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      lease = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, lease, submessage_arena);
    }
    set_has_lease();
  } else {
    clear_has_lease();
  }
  lease_ = lease;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.NotLeaseHolderError.lease)
}

inline bool NotLeaseHolderError::has_range_id() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void NotLeaseHolderError::set_has_range_id() {
  _has_bits_[0] |= 0x00000010u;
}
inline void NotLeaseHolderError::clear_has_range_id() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void NotLeaseHolderError::clear_range_id() {
  range_id_ = GOOGLE_LONGLONG(0);
  clear_has_range_id();
}
inline ::google::protobuf::int64 NotLeaseHolderError::range_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.NotLeaseHolderError.range_id)
  return range_id_;
}
inline void NotLeaseHolderError::set_range_id(::google::protobuf::int64 value) {
  set_has_range_id();
  range_id_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.NotLeaseHolderError.range_id)
}

inline bool NotLeaseHolderError::has_custom_msg() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void NotLeaseHolderError::set_has_custom_msg() {
  _has_bits_[0] |= 0x00000001u;
}
inline void NotLeaseHolderError::clear_has_custom_msg() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void NotLeaseHolderError::clear_custom_msg() {
  custom_msg_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_custom_msg();
}
inline const ::std::string& NotLeaseHolderError::custom_msg() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.NotLeaseHolderError.custom_msg)
  return custom_msg_.GetNoArena();
}
inline void NotLeaseHolderError::set_custom_msg(const ::std::string& value) {
  set_has_custom_msg();
  custom_msg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.NotLeaseHolderError.custom_msg)
}
#if LANG_CXX11
inline void NotLeaseHolderError::set_custom_msg(::std::string&& value) {
  set_has_custom_msg();
  custom_msg_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.NotLeaseHolderError.custom_msg)
}
#endif
inline void NotLeaseHolderError::set_custom_msg(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_custom_msg();
  custom_msg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.NotLeaseHolderError.custom_msg)
}
inline void NotLeaseHolderError::set_custom_msg(const char* value, size_t size) {
  set_has_custom_msg();
  custom_msg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.NotLeaseHolderError.custom_msg)
}
inline ::std::string* NotLeaseHolderError::mutable_custom_msg() {
  set_has_custom_msg();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.NotLeaseHolderError.custom_msg)
  return custom_msg_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* NotLeaseHolderError::release_custom_msg() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.NotLeaseHolderError.custom_msg)
  if (!has_custom_msg()) {
    return NULL;
  }
  clear_has_custom_msg();
  return custom_msg_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void NotLeaseHolderError::set_allocated_custom_msg(::std::string* custom_msg) {
  if (custom_msg != NULL) {
    set_has_custom_msg();
  } else {
    clear_has_custom_msg();
  }
  custom_msg_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), custom_msg);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.NotLeaseHolderError.custom_msg)
}

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

// NodeUnavailableError

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

// UnsupportedRequestError

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

// RangeNotFoundError

inline bool RangeNotFoundError::has_range_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RangeNotFoundError::set_has_range_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RangeNotFoundError::clear_has_range_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RangeNotFoundError::clear_range_id() {
  range_id_ = GOOGLE_LONGLONG(0);
  clear_has_range_id();
}
inline ::google::protobuf::int64 RangeNotFoundError::range_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeNotFoundError.range_id)
  return range_id_;
}
inline void RangeNotFoundError::set_range_id(::google::protobuf::int64 value) {
  set_has_range_id();
  range_id_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.RangeNotFoundError.range_id)
}

inline bool RangeNotFoundError::has_store_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RangeNotFoundError::set_has_store_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RangeNotFoundError::clear_has_store_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RangeNotFoundError::clear_store_id() {
  store_id_ = GOOGLE_LONGLONG(0);
  clear_has_store_id();
}
inline ::google::protobuf::int64 RangeNotFoundError::store_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeNotFoundError.store_id)
  return store_id_;
}
inline void RangeNotFoundError::set_store_id(::google::protobuf::int64 value) {
  set_has_store_id();
  store_id_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.RangeNotFoundError.store_id)
}

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

// RangeKeyMismatchError

inline bool RangeKeyMismatchError::has_request_start_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RangeKeyMismatchError::set_has_request_start_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RangeKeyMismatchError::clear_has_request_start_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RangeKeyMismatchError::clear_request_start_key() {
  request_start_key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_request_start_key();
}
inline const ::std::string& RangeKeyMismatchError::request_start_key() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeKeyMismatchError.request_start_key)
  return request_start_key_.GetNoArena();
}
inline void RangeKeyMismatchError::set_request_start_key(const ::std::string& value) {
  set_has_request_start_key();
  request_start_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.RangeKeyMismatchError.request_start_key)
}
#if LANG_CXX11
inline void RangeKeyMismatchError::set_request_start_key(::std::string&& value) {
  set_has_request_start_key();
  request_start_key_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.RangeKeyMismatchError.request_start_key)
}
#endif
inline void RangeKeyMismatchError::set_request_start_key(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_request_start_key();
  request_start_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.RangeKeyMismatchError.request_start_key)
}
inline void RangeKeyMismatchError::set_request_start_key(const void* value, size_t size) {
  set_has_request_start_key();
  request_start_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.RangeKeyMismatchError.request_start_key)
}
inline ::std::string* RangeKeyMismatchError::mutable_request_start_key() {
  set_has_request_start_key();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.RangeKeyMismatchError.request_start_key)
  return request_start_key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RangeKeyMismatchError::release_request_start_key() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.RangeKeyMismatchError.request_start_key)
  if (!has_request_start_key()) {
    return NULL;
  }
  clear_has_request_start_key();
  return request_start_key_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RangeKeyMismatchError::set_allocated_request_start_key(::std::string* request_start_key) {
  if (request_start_key != NULL) {
    set_has_request_start_key();
  } else {
    clear_has_request_start_key();
  }
  request_start_key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), request_start_key);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.RangeKeyMismatchError.request_start_key)
}

inline bool RangeKeyMismatchError::has_request_end_key() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RangeKeyMismatchError::set_has_request_end_key() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RangeKeyMismatchError::clear_has_request_end_key() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RangeKeyMismatchError::clear_request_end_key() {
  request_end_key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_request_end_key();
}
inline const ::std::string& RangeKeyMismatchError::request_end_key() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeKeyMismatchError.request_end_key)
  return request_end_key_.GetNoArena();
}
inline void RangeKeyMismatchError::set_request_end_key(const ::std::string& value) {
  set_has_request_end_key();
  request_end_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.RangeKeyMismatchError.request_end_key)
}
#if LANG_CXX11
inline void RangeKeyMismatchError::set_request_end_key(::std::string&& value) {
  set_has_request_end_key();
  request_end_key_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.RangeKeyMismatchError.request_end_key)
}
#endif
inline void RangeKeyMismatchError::set_request_end_key(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_request_end_key();
  request_end_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.RangeKeyMismatchError.request_end_key)
}
inline void RangeKeyMismatchError::set_request_end_key(const void* value, size_t size) {
  set_has_request_end_key();
  request_end_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.RangeKeyMismatchError.request_end_key)
}
inline ::std::string* RangeKeyMismatchError::mutable_request_end_key() {
  set_has_request_end_key();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.RangeKeyMismatchError.request_end_key)
  return request_end_key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* RangeKeyMismatchError::release_request_end_key() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.RangeKeyMismatchError.request_end_key)
  if (!has_request_end_key()) {
    return NULL;
  }
  clear_has_request_end_key();
  return request_end_key_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void RangeKeyMismatchError::set_allocated_request_end_key(::std::string* request_end_key) {
  if (request_end_key != NULL) {
    set_has_request_end_key();
  } else {
    clear_has_request_end_key();
  }
  request_end_key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), request_end_key);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.RangeKeyMismatchError.request_end_key)
}

inline bool RangeKeyMismatchError::has_mismatched_range() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void RangeKeyMismatchError::set_has_mismatched_range() {
  _has_bits_[0] |= 0x00000004u;
}
inline void RangeKeyMismatchError::clear_has_mismatched_range() {
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::cockroach::roachpb::RangeDescriptor& RangeKeyMismatchError::_internal_mismatched_range() const {
  return *mismatched_range_;
}
inline const ::cockroach::roachpb::RangeDescriptor& RangeKeyMismatchError::mismatched_range() const {
  const ::cockroach::roachpb::RangeDescriptor* p = mismatched_range_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeKeyMismatchError.mismatched_range)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::RangeDescriptor*>(
      &::cockroach::roachpb::_RangeDescriptor_default_instance_);
}
inline ::cockroach::roachpb::RangeDescriptor* RangeKeyMismatchError::release_mismatched_range() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.RangeKeyMismatchError.mismatched_range)
  clear_has_mismatched_range();
  ::cockroach::roachpb::RangeDescriptor* temp = mismatched_range_;
  mismatched_range_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::RangeDescriptor* RangeKeyMismatchError::mutable_mismatched_range() {
  set_has_mismatched_range();
  if (mismatched_range_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::RangeDescriptor>(GetArenaNoVirtual());
    mismatched_range_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.RangeKeyMismatchError.mismatched_range)
  return mismatched_range_;
}
inline void RangeKeyMismatchError::set_allocated_mismatched_range(::cockroach::roachpb::RangeDescriptor* mismatched_range) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(mismatched_range_);
  }
  if (mismatched_range) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      mismatched_range = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, mismatched_range, submessage_arena);
    }
    set_has_mismatched_range();
  } else {
    clear_has_mismatched_range();
  }
  mismatched_range_ = mismatched_range;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.RangeKeyMismatchError.mismatched_range)
}

// optional .cockroach.roachpb.RangeDescriptor suggested_range = 4;
inline bool RangeKeyMismatchError::has_suggested_range() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void RangeKeyMismatchError::set_has_suggested_range() {
  _has_bits_[0] |= 0x00000008u;
}
inline void RangeKeyMismatchError::clear_has_suggested_range() {
  _has_bits_[0] &= ~0x00000008u;
}
inline const ::cockroach::roachpb::RangeDescriptor& RangeKeyMismatchError::_internal_suggested_range() const {
  return *suggested_range_;
}
inline const ::cockroach::roachpb::RangeDescriptor& RangeKeyMismatchError::suggested_range() const {
  const ::cockroach::roachpb::RangeDescriptor* p = suggested_range_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeKeyMismatchError.suggested_range)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::RangeDescriptor*>(
      &::cockroach::roachpb::_RangeDescriptor_default_instance_);
}
inline ::cockroach::roachpb::RangeDescriptor* RangeKeyMismatchError::release_suggested_range() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.RangeKeyMismatchError.suggested_range)
  clear_has_suggested_range();
  ::cockroach::roachpb::RangeDescriptor* temp = suggested_range_;
  suggested_range_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::RangeDescriptor* RangeKeyMismatchError::mutable_suggested_range() {
  set_has_suggested_range();
  if (suggested_range_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::RangeDescriptor>(GetArenaNoVirtual());
    suggested_range_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.RangeKeyMismatchError.suggested_range)
  return suggested_range_;
}
inline void RangeKeyMismatchError::set_allocated_suggested_range(::cockroach::roachpb::RangeDescriptor* suggested_range) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(suggested_range_);
  }
  if (suggested_range) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      suggested_range = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, suggested_range, submessage_arena);
    }
    set_has_suggested_range();
  } else {
    clear_has_suggested_range();
  }
  suggested_range_ = suggested_range;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.RangeKeyMismatchError.suggested_range)
}

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

// ReadWithinUncertaintyIntervalError

inline bool ReadWithinUncertaintyIntervalError::has_read_timestamp() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReadWithinUncertaintyIntervalError::set_has_read_timestamp() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ReadWithinUncertaintyIntervalError::clear_has_read_timestamp() {
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::cockroach::util::hlc::Timestamp& ReadWithinUncertaintyIntervalError::_internal_read_timestamp() const {
  return *read_timestamp_;
}
inline const ::cockroach::util::hlc::Timestamp& ReadWithinUncertaintyIntervalError::read_timestamp() const {
  const ::cockroach::util::hlc::Timestamp* p = read_timestamp_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ReadWithinUncertaintyIntervalError.read_timestamp)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::util::hlc::Timestamp*>(
      &::cockroach::util::hlc::_Timestamp_default_instance_);
}
inline ::cockroach::util::hlc::Timestamp* ReadWithinUncertaintyIntervalError::release_read_timestamp() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ReadWithinUncertaintyIntervalError.read_timestamp)
  clear_has_read_timestamp();
  ::cockroach::util::hlc::Timestamp* temp = read_timestamp_;
  read_timestamp_ = NULL;
  return temp;
}
inline ::cockroach::util::hlc::Timestamp* ReadWithinUncertaintyIntervalError::mutable_read_timestamp() {
  set_has_read_timestamp();
  if (read_timestamp_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::util::hlc::Timestamp>(GetArenaNoVirtual());
    read_timestamp_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ReadWithinUncertaintyIntervalError.read_timestamp)
  return read_timestamp_;
}
inline void ReadWithinUncertaintyIntervalError::set_allocated_read_timestamp(::cockroach::util::hlc::Timestamp* read_timestamp) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(read_timestamp_);
  }
  if (read_timestamp) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      read_timestamp = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, read_timestamp, submessage_arena);
    }
    set_has_read_timestamp();
  } else {
    clear_has_read_timestamp();
  }
  read_timestamp_ = read_timestamp;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.ReadWithinUncertaintyIntervalError.read_timestamp)
}

inline bool ReadWithinUncertaintyIntervalError::has_existing_timestamp() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ReadWithinUncertaintyIntervalError::set_has_existing_timestamp() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ReadWithinUncertaintyIntervalError::clear_has_existing_timestamp() {
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::cockroach::util::hlc::Timestamp& ReadWithinUncertaintyIntervalError::_internal_existing_timestamp() const {
  return *existing_timestamp_;
}
inline const ::cockroach::util::hlc::Timestamp& ReadWithinUncertaintyIntervalError::existing_timestamp() const {
  const ::cockroach::util::hlc::Timestamp* p = existing_timestamp_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ReadWithinUncertaintyIntervalError.existing_timestamp)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::util::hlc::Timestamp*>(
      &::cockroach::util::hlc::_Timestamp_default_instance_);
}
inline ::cockroach::util::hlc::Timestamp* ReadWithinUncertaintyIntervalError::release_existing_timestamp() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ReadWithinUncertaintyIntervalError.existing_timestamp)
  clear_has_existing_timestamp();
  ::cockroach::util::hlc::Timestamp* temp = existing_timestamp_;
  existing_timestamp_ = NULL;
  return temp;
}
inline ::cockroach::util::hlc::Timestamp* ReadWithinUncertaintyIntervalError::mutable_existing_timestamp() {
  set_has_existing_timestamp();
  if (existing_timestamp_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::util::hlc::Timestamp>(GetArenaNoVirtual());
    existing_timestamp_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ReadWithinUncertaintyIntervalError.existing_timestamp)
  return existing_timestamp_;
}
inline void ReadWithinUncertaintyIntervalError::set_allocated_existing_timestamp(::cockroach::util::hlc::Timestamp* existing_timestamp) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(existing_timestamp_);
  }
  if (existing_timestamp) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      existing_timestamp = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, existing_timestamp, submessage_arena);
    }
    set_has_existing_timestamp();
  } else {
    clear_has_existing_timestamp();
  }
  existing_timestamp_ = existing_timestamp;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.ReadWithinUncertaintyIntervalError.existing_timestamp)
}

// optional .cockroach.util.hlc.Timestamp max_timestamp = 3;
inline bool ReadWithinUncertaintyIntervalError::has_max_timestamp() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ReadWithinUncertaintyIntervalError::set_has_max_timestamp() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ReadWithinUncertaintyIntervalError::clear_has_max_timestamp() {
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::cockroach::util::hlc::Timestamp& ReadWithinUncertaintyIntervalError::_internal_max_timestamp() const {
  return *max_timestamp_;
}
inline const ::cockroach::util::hlc::Timestamp& ReadWithinUncertaintyIntervalError::max_timestamp() const {
  const ::cockroach::util::hlc::Timestamp* p = max_timestamp_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ReadWithinUncertaintyIntervalError.max_timestamp)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::util::hlc::Timestamp*>(
      &::cockroach::util::hlc::_Timestamp_default_instance_);
}
inline ::cockroach::util::hlc::Timestamp* ReadWithinUncertaintyIntervalError::release_max_timestamp() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ReadWithinUncertaintyIntervalError.max_timestamp)
  clear_has_max_timestamp();
  ::cockroach::util::hlc::Timestamp* temp = max_timestamp_;
  max_timestamp_ = NULL;
  return temp;
}
inline ::cockroach::util::hlc::Timestamp* ReadWithinUncertaintyIntervalError::mutable_max_timestamp() {
  set_has_max_timestamp();
  if (max_timestamp_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::util::hlc::Timestamp>(GetArenaNoVirtual());
    max_timestamp_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ReadWithinUncertaintyIntervalError.max_timestamp)
  return max_timestamp_;
}
inline void ReadWithinUncertaintyIntervalError::set_allocated_max_timestamp(::cockroach::util::hlc::Timestamp* max_timestamp) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(max_timestamp_);
  }
  if (max_timestamp) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      max_timestamp = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, max_timestamp, submessage_arena);
    }
    set_has_max_timestamp();
  } else {
    clear_has_max_timestamp();
  }
  max_timestamp_ = max_timestamp;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.ReadWithinUncertaintyIntervalError.max_timestamp)
}

inline int ReadWithinUncertaintyIntervalError::observed_timestamps_size() const {
  return observed_timestamps_.size();
}
inline ::cockroach::roachpb::ObservedTimestamp* ReadWithinUncertaintyIntervalError::mutable_observed_timestamps(int index) {
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ReadWithinUncertaintyIntervalError.observed_timestamps)
  return observed_timestamps_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ObservedTimestamp >*
ReadWithinUncertaintyIntervalError::mutable_observed_timestamps() {
  // @@protoc_insertion_point(field_mutable_list:cockroach.roachpb.ReadWithinUncertaintyIntervalError.observed_timestamps)
  return &observed_timestamps_;
}
inline const ::cockroach::roachpb::ObservedTimestamp& ReadWithinUncertaintyIntervalError::observed_timestamps(int index) const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ReadWithinUncertaintyIntervalError.observed_timestamps)
  return observed_timestamps_.Get(index);
}
inline ::cockroach::roachpb::ObservedTimestamp* ReadWithinUncertaintyIntervalError::add_observed_timestamps() {
  // @@protoc_insertion_point(field_add:cockroach.roachpb.ReadWithinUncertaintyIntervalError.observed_timestamps)
  return observed_timestamps_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::ObservedTimestamp >&
ReadWithinUncertaintyIntervalError::observed_timestamps() const {
  // @@protoc_insertion_point(field_list:cockroach.roachpb.ReadWithinUncertaintyIntervalError.observed_timestamps)
  return observed_timestamps_;
}

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

// TransactionAbortedError

inline bool TransactionAbortedError::has_reason() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TransactionAbortedError::set_has_reason() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TransactionAbortedError::clear_has_reason() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TransactionAbortedError::clear_reason() {
  reason_ = 0;
  clear_has_reason();
}
inline ::cockroach::roachpb::TransactionAbortedReason TransactionAbortedError::reason() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.TransactionAbortedError.reason)
  return static_cast< ::cockroach::roachpb::TransactionAbortedReason >(reason_);
}
inline void TransactionAbortedError::set_reason(::cockroach::roachpb::TransactionAbortedReason value) {
  assert(::cockroach::roachpb::TransactionAbortedReason_IsValid(value));
  set_has_reason();
  reason_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.TransactionAbortedError.reason)
}

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

// TransactionPushError

inline bool TransactionPushError::has_pushee_txn() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TransactionPushError::set_has_pushee_txn() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TransactionPushError::clear_has_pushee_txn() {
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::cockroach::roachpb::Transaction& TransactionPushError::_internal_pushee_txn() const {
  return *pushee_txn_;
}
inline const ::cockroach::roachpb::Transaction& TransactionPushError::pushee_txn() const {
  const ::cockroach::roachpb::Transaction* p = pushee_txn_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.TransactionPushError.pushee_txn)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Transaction*>(
      &::cockroach::roachpb::_Transaction_default_instance_);
}
inline ::cockroach::roachpb::Transaction* TransactionPushError::release_pushee_txn() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.TransactionPushError.pushee_txn)
  clear_has_pushee_txn();
  ::cockroach::roachpb::Transaction* temp = pushee_txn_;
  pushee_txn_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Transaction* TransactionPushError::mutable_pushee_txn() {
  set_has_pushee_txn();
  if (pushee_txn_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Transaction>(GetArenaNoVirtual());
    pushee_txn_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.TransactionPushError.pushee_txn)
  return pushee_txn_;
}
inline void TransactionPushError::set_allocated_pushee_txn(::cockroach::roachpb::Transaction* pushee_txn) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(pushee_txn_);
  }
  if (pushee_txn) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      pushee_txn = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, pushee_txn, submessage_arena);
    }
    set_has_pushee_txn();
  } else {
    clear_has_pushee_txn();
  }
  pushee_txn_ = pushee_txn;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.TransactionPushError.pushee_txn)
}

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

// TransactionRetryError

inline bool TransactionRetryError::has_reason() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TransactionRetryError::set_has_reason() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TransactionRetryError::clear_has_reason() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TransactionRetryError::clear_reason() {
  reason_ = 0;
  clear_has_reason();
}
inline ::cockroach::roachpb::TransactionRetryReason TransactionRetryError::reason() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.TransactionRetryError.reason)
  return static_cast< ::cockroach::roachpb::TransactionRetryReason >(reason_);
}
inline void TransactionRetryError::set_reason(::cockroach::roachpb::TransactionRetryReason value) {
  assert(::cockroach::roachpb::TransactionRetryReason_IsValid(value));
  set_has_reason();
  reason_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.TransactionRetryError.reason)
}

inline bool TransactionRetryError::has_extra_msg() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TransactionRetryError::set_has_extra_msg() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TransactionRetryError::clear_has_extra_msg() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TransactionRetryError::clear_extra_msg() {
  extra_msg_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_extra_msg();
}
inline const ::std::string& TransactionRetryError::extra_msg() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.TransactionRetryError.extra_msg)
  return extra_msg_.GetNoArena();
}
inline void TransactionRetryError::set_extra_msg(const ::std::string& value) {
  set_has_extra_msg();
  extra_msg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.TransactionRetryError.extra_msg)
}
#if LANG_CXX11
inline void TransactionRetryError::set_extra_msg(::std::string&& value) {
  set_has_extra_msg();
  extra_msg_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.TransactionRetryError.extra_msg)
}
#endif
inline void TransactionRetryError::set_extra_msg(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_extra_msg();
  extra_msg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.TransactionRetryError.extra_msg)
}
inline void TransactionRetryError::set_extra_msg(const char* value, size_t size) {
  set_has_extra_msg();
  extra_msg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.TransactionRetryError.extra_msg)
}
inline ::std::string* TransactionRetryError::mutable_extra_msg() {
  set_has_extra_msg();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.TransactionRetryError.extra_msg)
  return extra_msg_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TransactionRetryError::release_extra_msg() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.TransactionRetryError.extra_msg)
  if (!has_extra_msg()) {
    return NULL;
  }
  clear_has_extra_msg();
  return extra_msg_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TransactionRetryError::set_allocated_extra_msg(::std::string* extra_msg) {
  if (extra_msg != NULL) {
    set_has_extra_msg();
  } else {
    clear_has_extra_msg();
  }
  extra_msg_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), extra_msg);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.TransactionRetryError.extra_msg)
}

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

// TransactionStatusError

inline bool TransactionStatusError::has_msg() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TransactionStatusError::set_has_msg() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TransactionStatusError::clear_has_msg() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TransactionStatusError::clear_msg() {
  msg_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_msg();
}
inline const ::std::string& TransactionStatusError::msg() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.TransactionStatusError.msg)
  return msg_.GetNoArena();
}
inline void TransactionStatusError::set_msg(const ::std::string& value) {
  set_has_msg();
  msg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.TransactionStatusError.msg)
}
#if LANG_CXX11
inline void TransactionStatusError::set_msg(::std::string&& value) {
  set_has_msg();
  msg_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.TransactionStatusError.msg)
}
#endif
inline void TransactionStatusError::set_msg(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_msg();
  msg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.TransactionStatusError.msg)
}
inline void TransactionStatusError::set_msg(const char* value, size_t size) {
  set_has_msg();
  msg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.TransactionStatusError.msg)
}
inline ::std::string* TransactionStatusError::mutable_msg() {
  set_has_msg();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.TransactionStatusError.msg)
  return msg_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TransactionStatusError::release_msg() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.TransactionStatusError.msg)
  if (!has_msg()) {
    return NULL;
  }
  clear_has_msg();
  return msg_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TransactionStatusError::set_allocated_msg(::std::string* msg) {
  if (msg != NULL) {
    set_has_msg();
  } else {
    clear_has_msg();
  }
  msg_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), msg);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.TransactionStatusError.msg)
}

inline bool TransactionStatusError::has_reason() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TransactionStatusError::set_has_reason() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TransactionStatusError::clear_has_reason() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TransactionStatusError::clear_reason() {
  reason_ = 0;
  clear_has_reason();
}
inline ::cockroach::roachpb::TransactionStatusError_Reason TransactionStatusError::reason() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.TransactionStatusError.reason)
  return static_cast< ::cockroach::roachpb::TransactionStatusError_Reason >(reason_);
}
inline void TransactionStatusError::set_reason(::cockroach::roachpb::TransactionStatusError_Reason value) {
  assert(::cockroach::roachpb::TransactionStatusError_Reason_IsValid(value));
  set_has_reason();
  reason_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.TransactionStatusError.reason)
}

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

// WriteIntentError

inline int WriteIntentError::intents_size() const {
  return intents_.size();
}
inline ::cockroach::roachpb::Intent* WriteIntentError::mutable_intents(int index) {
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.WriteIntentError.intents)
  return intents_.Mutable(index);
}
inline ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::Intent >*
WriteIntentError::mutable_intents() {
  // @@protoc_insertion_point(field_mutable_list:cockroach.roachpb.WriteIntentError.intents)
  return &intents_;
}
inline const ::cockroach::roachpb::Intent& WriteIntentError::intents(int index) const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.WriteIntentError.intents)
  return intents_.Get(index);
}
inline ::cockroach::roachpb::Intent* WriteIntentError::add_intents() {
  // @@protoc_insertion_point(field_add:cockroach.roachpb.WriteIntentError.intents)
  return intents_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::cockroach::roachpb::Intent >&
WriteIntentError::intents() const {
  // @@protoc_insertion_point(field_list:cockroach.roachpb.WriteIntentError.intents)
  return intents_;
}

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

// WriteTooOldError

inline bool WriteTooOldError::has_timestamp() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void WriteTooOldError::set_has_timestamp() {
  _has_bits_[0] |= 0x00000001u;
}
inline void WriteTooOldError::clear_has_timestamp() {
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::cockroach::util::hlc::Timestamp& WriteTooOldError::_internal_timestamp() const {
  return *timestamp_;
}
inline const ::cockroach::util::hlc::Timestamp& WriteTooOldError::timestamp() const {
  const ::cockroach::util::hlc::Timestamp* p = timestamp_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.WriteTooOldError.timestamp)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::util::hlc::Timestamp*>(
      &::cockroach::util::hlc::_Timestamp_default_instance_);
}
inline ::cockroach::util::hlc::Timestamp* WriteTooOldError::release_timestamp() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.WriteTooOldError.timestamp)
  clear_has_timestamp();
  ::cockroach::util::hlc::Timestamp* temp = timestamp_;
  timestamp_ = NULL;
  return temp;
}
inline ::cockroach::util::hlc::Timestamp* WriteTooOldError::mutable_timestamp() {
  set_has_timestamp();
  if (timestamp_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::util::hlc::Timestamp>(GetArenaNoVirtual());
    timestamp_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.WriteTooOldError.timestamp)
  return timestamp_;
}
inline void WriteTooOldError::set_allocated_timestamp(::cockroach::util::hlc::Timestamp* timestamp) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
  }
  if (timestamp) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      timestamp = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, timestamp, submessage_arena);
    }
    set_has_timestamp();
  } else {
    clear_has_timestamp();
  }
  timestamp_ = timestamp;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.WriteTooOldError.timestamp)
}

inline bool WriteTooOldError::has_actual_timestamp() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void WriteTooOldError::set_has_actual_timestamp() {
  _has_bits_[0] |= 0x00000002u;
}
inline void WriteTooOldError::clear_has_actual_timestamp() {
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::cockroach::util::hlc::Timestamp& WriteTooOldError::_internal_actual_timestamp() const {
  return *actual_timestamp_;
}
inline const ::cockroach::util::hlc::Timestamp& WriteTooOldError::actual_timestamp() const {
  const ::cockroach::util::hlc::Timestamp* p = actual_timestamp_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.WriteTooOldError.actual_timestamp)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::util::hlc::Timestamp*>(
      &::cockroach::util::hlc::_Timestamp_default_instance_);
}
inline ::cockroach::util::hlc::Timestamp* WriteTooOldError::release_actual_timestamp() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.WriteTooOldError.actual_timestamp)
  clear_has_actual_timestamp();
  ::cockroach::util::hlc::Timestamp* temp = actual_timestamp_;
  actual_timestamp_ = NULL;
  return temp;
}
inline ::cockroach::util::hlc::Timestamp* WriteTooOldError::mutable_actual_timestamp() {
  set_has_actual_timestamp();
  if (actual_timestamp_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::util::hlc::Timestamp>(GetArenaNoVirtual());
    actual_timestamp_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.WriteTooOldError.actual_timestamp)
  return actual_timestamp_;
}
inline void WriteTooOldError::set_allocated_actual_timestamp(::cockroach::util::hlc::Timestamp* actual_timestamp) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(actual_timestamp_);
  }
  if (actual_timestamp) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      actual_timestamp = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, actual_timestamp, submessage_arena);
    }
    set_has_actual_timestamp();
  } else {
    clear_has_actual_timestamp();
  }
  actual_timestamp_ = actual_timestamp;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.WriteTooOldError.actual_timestamp)
}

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

// OpRequiresTxnError

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

// ConditionFailedError

// optional .cockroach.roachpb.Value actual_value = 1;
inline bool ConditionFailedError::has_actual_value() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ConditionFailedError::set_has_actual_value() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ConditionFailedError::clear_has_actual_value() {
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::cockroach::roachpb::Value& ConditionFailedError::_internal_actual_value() const {
  return *actual_value_;
}
inline const ::cockroach::roachpb::Value& ConditionFailedError::actual_value() const {
  const ::cockroach::roachpb::Value* p = actual_value_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ConditionFailedError.actual_value)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Value*>(
      &::cockroach::roachpb::_Value_default_instance_);
}
inline ::cockroach::roachpb::Value* ConditionFailedError::release_actual_value() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ConditionFailedError.actual_value)
  clear_has_actual_value();
  ::cockroach::roachpb::Value* temp = actual_value_;
  actual_value_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Value* ConditionFailedError::mutable_actual_value() {
  set_has_actual_value();
  if (actual_value_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Value>(GetArenaNoVirtual());
    actual_value_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ConditionFailedError.actual_value)
  return actual_value_;
}
inline void ConditionFailedError::set_allocated_actual_value(::cockroach::roachpb::Value* actual_value) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(actual_value_);
  }
  if (actual_value) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      actual_value = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, actual_value, submessage_arena);
    }
    set_has_actual_value();
  } else {
    clear_has_actual_value();
  }
  actual_value_ = actual_value;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.ConditionFailedError.actual_value)
}

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

// LeaseRejectedError

inline bool LeaseRejectedError::has_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void LeaseRejectedError::set_has_message() {
  _has_bits_[0] |= 0x00000001u;
}
inline void LeaseRejectedError::clear_has_message() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void LeaseRejectedError::clear_message() {
  message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_message();
}
inline const ::std::string& LeaseRejectedError::message() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.LeaseRejectedError.message)
  return message_.GetNoArena();
}
inline void LeaseRejectedError::set_message(const ::std::string& value) {
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.LeaseRejectedError.message)
}
#if LANG_CXX11
inline void LeaseRejectedError::set_message(::std::string&& value) {
  set_has_message();
  message_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.LeaseRejectedError.message)
}
#endif
inline void LeaseRejectedError::set_message(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.LeaseRejectedError.message)
}
inline void LeaseRejectedError::set_message(const char* value, size_t size) {
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.LeaseRejectedError.message)
}
inline ::std::string* LeaseRejectedError::mutable_message() {
  set_has_message();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.LeaseRejectedError.message)
  return message_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* LeaseRejectedError::release_message() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.LeaseRejectedError.message)
  if (!has_message()) {
    return NULL;
  }
  clear_has_message();
  return message_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void LeaseRejectedError::set_allocated_message(::std::string* message) {
  if (message != NULL) {
    set_has_message();
  } else {
    clear_has_message();
  }
  message_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), message);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.LeaseRejectedError.message)
}

inline bool LeaseRejectedError::has_requested() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void LeaseRejectedError::set_has_requested() {
  _has_bits_[0] |= 0x00000002u;
}
inline void LeaseRejectedError::clear_has_requested() {
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::cockroach::roachpb::Lease& LeaseRejectedError::_internal_requested() const {
  return *requested_;
}
inline const ::cockroach::roachpb::Lease& LeaseRejectedError::requested() const {
  const ::cockroach::roachpb::Lease* p = requested_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.LeaseRejectedError.requested)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Lease*>(
      &::cockroach::roachpb::_Lease_default_instance_);
}
inline ::cockroach::roachpb::Lease* LeaseRejectedError::release_requested() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.LeaseRejectedError.requested)
  clear_has_requested();
  ::cockroach::roachpb::Lease* temp = requested_;
  requested_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Lease* LeaseRejectedError::mutable_requested() {
  set_has_requested();
  if (requested_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Lease>(GetArenaNoVirtual());
    requested_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.LeaseRejectedError.requested)
  return requested_;
}
inline void LeaseRejectedError::set_allocated_requested(::cockroach::roachpb::Lease* requested) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(requested_);
  }
  if (requested) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      requested = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, requested, submessage_arena);
    }
    set_has_requested();
  } else {
    clear_has_requested();
  }
  requested_ = requested;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.LeaseRejectedError.requested)
}

inline bool LeaseRejectedError::has_existing() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void LeaseRejectedError::set_has_existing() {
  _has_bits_[0] |= 0x00000004u;
}
inline void LeaseRejectedError::clear_has_existing() {
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::cockroach::roachpb::Lease& LeaseRejectedError::_internal_existing() const {
  return *existing_;
}
inline const ::cockroach::roachpb::Lease& LeaseRejectedError::existing() const {
  const ::cockroach::roachpb::Lease* p = existing_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.LeaseRejectedError.existing)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Lease*>(
      &::cockroach::roachpb::_Lease_default_instance_);
}
inline ::cockroach::roachpb::Lease* LeaseRejectedError::release_existing() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.LeaseRejectedError.existing)
  clear_has_existing();
  ::cockroach::roachpb::Lease* temp = existing_;
  existing_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Lease* LeaseRejectedError::mutable_existing() {
  set_has_existing();
  if (existing_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Lease>(GetArenaNoVirtual());
    existing_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.LeaseRejectedError.existing)
  return existing_;
}
inline void LeaseRejectedError::set_allocated_existing(::cockroach::roachpb::Lease* existing) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(existing_);
  }
  if (existing) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      existing = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, existing, submessage_arena);
    }
    set_has_existing();
  } else {
    clear_has_existing();
  }
  existing_ = existing;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.LeaseRejectedError.existing)
}

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

// SendError

inline bool SendError::has_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SendError::set_has_message() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SendError::clear_has_message() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SendError::clear_message() {
  message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_message();
}
inline const ::std::string& SendError::message() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.SendError.message)
  return message_.GetNoArena();
}
inline void SendError::set_message(const ::std::string& value) {
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.SendError.message)
}
#if LANG_CXX11
inline void SendError::set_message(::std::string&& value) {
  set_has_message();
  message_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.SendError.message)
}
#endif
inline void SendError::set_message(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.SendError.message)
}
inline void SendError::set_message(const char* value, size_t size) {
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.SendError.message)
}
inline ::std::string* SendError::mutable_message() {
  set_has_message();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.SendError.message)
  return message_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SendError::release_message() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.SendError.message)
  if (!has_message()) {
    return NULL;
  }
  clear_has_message();
  return message_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SendError::set_allocated_message(::std::string* message) {
  if (message != NULL) {
    set_has_message();
  } else {
    clear_has_message();
  }
  message_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), message);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.SendError.message)
}

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

// AmbiguousResultError

inline bool AmbiguousResultError::has_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AmbiguousResultError::set_has_message() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AmbiguousResultError::clear_has_message() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AmbiguousResultError::clear_message() {
  message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_message();
}
inline const ::std::string& AmbiguousResultError::message() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.AmbiguousResultError.message)
  return message_.GetNoArena();
}
inline void AmbiguousResultError::set_message(const ::std::string& value) {
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.AmbiguousResultError.message)
}
#if LANG_CXX11
inline void AmbiguousResultError::set_message(::std::string&& value) {
  set_has_message();
  message_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.AmbiguousResultError.message)
}
#endif
inline void AmbiguousResultError::set_message(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.AmbiguousResultError.message)
}
inline void AmbiguousResultError::set_message(const char* value, size_t size) {
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.AmbiguousResultError.message)
}
inline ::std::string* AmbiguousResultError::mutable_message() {
  set_has_message();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.AmbiguousResultError.message)
  return message_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* AmbiguousResultError::release_message() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.AmbiguousResultError.message)
  if (!has_message()) {
    return NULL;
  }
  clear_has_message();
  return message_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void AmbiguousResultError::set_allocated_message(::std::string* message) {
  if (message != NULL) {
    set_has_message();
  } else {
    clear_has_message();
  }
  message_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), message);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.AmbiguousResultError.message)
}

// optional .cockroach.roachpb.Error wrapped_err = 2;
inline bool AmbiguousResultError::has_wrapped_err() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void AmbiguousResultError::set_has_wrapped_err() {
  _has_bits_[0] |= 0x00000002u;
}
inline void AmbiguousResultError::clear_has_wrapped_err() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void AmbiguousResultError::clear_wrapped_err() {
  if (wrapped_err_ != NULL) wrapped_err_->Clear();
  clear_has_wrapped_err();
}
inline const ::cockroach::roachpb::Error& AmbiguousResultError::_internal_wrapped_err() const {
  return *wrapped_err_;
}
inline const ::cockroach::roachpb::Error& AmbiguousResultError::wrapped_err() const {
  const ::cockroach::roachpb::Error* p = wrapped_err_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.AmbiguousResultError.wrapped_err)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Error*>(
      &::cockroach::roachpb::_Error_default_instance_);
}
inline ::cockroach::roachpb::Error* AmbiguousResultError::release_wrapped_err() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.AmbiguousResultError.wrapped_err)
  clear_has_wrapped_err();
  ::cockroach::roachpb::Error* temp = wrapped_err_;
  wrapped_err_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Error* AmbiguousResultError::mutable_wrapped_err() {
  set_has_wrapped_err();
  if (wrapped_err_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Error>(GetArenaNoVirtual());
    wrapped_err_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.AmbiguousResultError.wrapped_err)
  return wrapped_err_;
}
inline void AmbiguousResultError::set_allocated_wrapped_err(::cockroach::roachpb::Error* wrapped_err) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete wrapped_err_;
  }
  if (wrapped_err) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      wrapped_err = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, wrapped_err, submessage_arena);
    }
    set_has_wrapped_err();
  } else {
    clear_has_wrapped_err();
  }
  wrapped_err_ = wrapped_err;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.AmbiguousResultError.wrapped_err)
}

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

// RaftGroupDeletedError

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

// ReplicaCorruptionError

inline bool ReplicaCorruptionError::has_error_msg() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReplicaCorruptionError::set_has_error_msg() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ReplicaCorruptionError::clear_has_error_msg() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ReplicaCorruptionError::clear_error_msg() {
  error_msg_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_error_msg();
}
inline const ::std::string& ReplicaCorruptionError::error_msg() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ReplicaCorruptionError.error_msg)
  return error_msg_.GetNoArena();
}
inline void ReplicaCorruptionError::set_error_msg(const ::std::string& value) {
  set_has_error_msg();
  error_msg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.ReplicaCorruptionError.error_msg)
}
#if LANG_CXX11
inline void ReplicaCorruptionError::set_error_msg(::std::string&& value) {
  set_has_error_msg();
  error_msg_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.ReplicaCorruptionError.error_msg)
}
#endif
inline void ReplicaCorruptionError::set_error_msg(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_error_msg();
  error_msg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.ReplicaCorruptionError.error_msg)
}
inline void ReplicaCorruptionError::set_error_msg(const char* value, size_t size) {
  set_has_error_msg();
  error_msg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.ReplicaCorruptionError.error_msg)
}
inline ::std::string* ReplicaCorruptionError::mutable_error_msg() {
  set_has_error_msg();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ReplicaCorruptionError.error_msg)
  return error_msg_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ReplicaCorruptionError::release_error_msg() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ReplicaCorruptionError.error_msg)
  if (!has_error_msg()) {
    return NULL;
  }
  clear_has_error_msg();
  return error_msg_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ReplicaCorruptionError::set_allocated_error_msg(::std::string* error_msg) {
  if (error_msg != NULL) {
    set_has_error_msg();
  } else {
    clear_has_error_msg();
  }
  error_msg_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), error_msg);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.ReplicaCorruptionError.error_msg)
}

inline bool ReplicaCorruptionError::has_processed() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ReplicaCorruptionError::set_has_processed() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ReplicaCorruptionError::clear_has_processed() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ReplicaCorruptionError::clear_processed() {
  processed_ = false;
  clear_has_processed();
}
inline bool ReplicaCorruptionError::processed() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ReplicaCorruptionError.processed)
  return processed_;
}
inline void ReplicaCorruptionError::set_processed(bool value) {
  set_has_processed();
  processed_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.ReplicaCorruptionError.processed)
}

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

// ReplicaTooOldError

inline bool ReplicaTooOldError::has_replica_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ReplicaTooOldError::set_has_replica_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ReplicaTooOldError::clear_has_replica_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ReplicaTooOldError::clear_replica_id() {
  replica_id_ = 0;
  clear_has_replica_id();
}
inline ::google::protobuf::int32 ReplicaTooOldError::replica_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ReplicaTooOldError.replica_id)
  return replica_id_;
}
inline void ReplicaTooOldError::set_replica_id(::google::protobuf::int32 value) {
  set_has_replica_id();
  replica_id_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.ReplicaTooOldError.replica_id)
}

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

// StoreNotFoundError

inline bool StoreNotFoundError::has_store_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StoreNotFoundError::set_has_store_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StoreNotFoundError::clear_has_store_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StoreNotFoundError::clear_store_id() {
  store_id_ = GOOGLE_LONGLONG(0);
  clear_has_store_id();
}
inline ::google::protobuf::int64 StoreNotFoundError::store_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.StoreNotFoundError.store_id)
  return store_id_;
}
inline void StoreNotFoundError::set_store_id(::google::protobuf::int64 value) {
  set_has_store_id();
  store_id_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.StoreNotFoundError.store_id)
}

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

// UnhandledRetryableError

inline bool UnhandledRetryableError::has_perr() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void UnhandledRetryableError::set_has_perr() {
  _has_bits_[0] |= 0x00000001u;
}
inline void UnhandledRetryableError::clear_has_perr() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void UnhandledRetryableError::clear_perr() {
  if (perr_ != NULL) perr_->Clear();
  clear_has_perr();
}
inline const ::cockroach::roachpb::Error& UnhandledRetryableError::_internal_perr() const {
  return *perr_;
}
inline const ::cockroach::roachpb::Error& UnhandledRetryableError::perr() const {
  const ::cockroach::roachpb::Error* p = perr_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.UnhandledRetryableError.pErr)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Error*>(
      &::cockroach::roachpb::_Error_default_instance_);
}
inline ::cockroach::roachpb::Error* UnhandledRetryableError::release_perr() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.UnhandledRetryableError.pErr)
  clear_has_perr();
  ::cockroach::roachpb::Error* temp = perr_;
  perr_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Error* UnhandledRetryableError::mutable_perr() {
  set_has_perr();
  if (perr_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Error>(GetArenaNoVirtual());
    perr_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.UnhandledRetryableError.pErr)
  return perr_;
}
inline void UnhandledRetryableError::set_allocated_perr(::cockroach::roachpb::Error* perr) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete perr_;
  }
  if (perr) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      perr = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, perr, submessage_arena);
    }
    set_has_perr();
  } else {
    clear_has_perr();
  }
  perr_ = perr;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.UnhandledRetryableError.pErr)
}

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

// TransactionRetryWithProtoRefreshError

inline bool TransactionRetryWithProtoRefreshError::has_msg() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TransactionRetryWithProtoRefreshError::set_has_msg() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TransactionRetryWithProtoRefreshError::clear_has_msg() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TransactionRetryWithProtoRefreshError::clear_msg() {
  msg_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_msg();
}
inline const ::std::string& TransactionRetryWithProtoRefreshError::msg() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.TransactionRetryWithProtoRefreshError.msg)
  return msg_.GetNoArena();
}
inline void TransactionRetryWithProtoRefreshError::set_msg(const ::std::string& value) {
  set_has_msg();
  msg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.TransactionRetryWithProtoRefreshError.msg)
}
#if LANG_CXX11
inline void TransactionRetryWithProtoRefreshError::set_msg(::std::string&& value) {
  set_has_msg();
  msg_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.TransactionRetryWithProtoRefreshError.msg)
}
#endif
inline void TransactionRetryWithProtoRefreshError::set_msg(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_msg();
  msg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.TransactionRetryWithProtoRefreshError.msg)
}
inline void TransactionRetryWithProtoRefreshError::set_msg(const char* value, size_t size) {
  set_has_msg();
  msg_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.TransactionRetryWithProtoRefreshError.msg)
}
inline ::std::string* TransactionRetryWithProtoRefreshError::mutable_msg() {
  set_has_msg();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.TransactionRetryWithProtoRefreshError.msg)
  return msg_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TransactionRetryWithProtoRefreshError::release_msg() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.TransactionRetryWithProtoRefreshError.msg)
  if (!has_msg()) {
    return NULL;
  }
  clear_has_msg();
  return msg_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TransactionRetryWithProtoRefreshError::set_allocated_msg(::std::string* msg) {
  if (msg != NULL) {
    set_has_msg();
  } else {
    clear_has_msg();
  }
  msg_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), msg);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.TransactionRetryWithProtoRefreshError.msg)
}

inline bool TransactionRetryWithProtoRefreshError::has_txn_id() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void TransactionRetryWithProtoRefreshError::set_has_txn_id() {
  _has_bits_[0] |= 0x00000002u;
}
inline void TransactionRetryWithProtoRefreshError::clear_has_txn_id() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void TransactionRetryWithProtoRefreshError::clear_txn_id() {
  txn_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_txn_id();
}
inline const ::std::string& TransactionRetryWithProtoRefreshError::txn_id() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.TransactionRetryWithProtoRefreshError.txn_id)
  return txn_id_.GetNoArena();
}
inline void TransactionRetryWithProtoRefreshError::set_txn_id(const ::std::string& value) {
  set_has_txn_id();
  txn_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.TransactionRetryWithProtoRefreshError.txn_id)
}
#if LANG_CXX11
inline void TransactionRetryWithProtoRefreshError::set_txn_id(::std::string&& value) {
  set_has_txn_id();
  txn_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.TransactionRetryWithProtoRefreshError.txn_id)
}
#endif
inline void TransactionRetryWithProtoRefreshError::set_txn_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_txn_id();
  txn_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.TransactionRetryWithProtoRefreshError.txn_id)
}
inline void TransactionRetryWithProtoRefreshError::set_txn_id(const void* value, size_t size) {
  set_has_txn_id();
  txn_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.TransactionRetryWithProtoRefreshError.txn_id)
}
inline ::std::string* TransactionRetryWithProtoRefreshError::mutable_txn_id() {
  set_has_txn_id();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.TransactionRetryWithProtoRefreshError.txn_id)
  return txn_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TransactionRetryWithProtoRefreshError::release_txn_id() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.TransactionRetryWithProtoRefreshError.txn_id)
  if (!has_txn_id()) {
    return NULL;
  }
  clear_has_txn_id();
  return txn_id_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TransactionRetryWithProtoRefreshError::set_allocated_txn_id(::std::string* txn_id) {
  if (txn_id != NULL) {
    set_has_txn_id();
  } else {
    clear_has_txn_id();
  }
  txn_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), txn_id);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.TransactionRetryWithProtoRefreshError.txn_id)
}

inline bool TransactionRetryWithProtoRefreshError::has_transaction() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void TransactionRetryWithProtoRefreshError::set_has_transaction() {
  _has_bits_[0] |= 0x00000004u;
}
inline void TransactionRetryWithProtoRefreshError::clear_has_transaction() {
  _has_bits_[0] &= ~0x00000004u;
}
inline const ::cockroach::roachpb::Transaction& TransactionRetryWithProtoRefreshError::_internal_transaction() const {
  return *transaction_;
}
inline const ::cockroach::roachpb::Transaction& TransactionRetryWithProtoRefreshError::transaction() const {
  const ::cockroach::roachpb::Transaction* p = transaction_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.TransactionRetryWithProtoRefreshError.transaction)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Transaction*>(
      &::cockroach::roachpb::_Transaction_default_instance_);
}
inline ::cockroach::roachpb::Transaction* TransactionRetryWithProtoRefreshError::release_transaction() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.TransactionRetryWithProtoRefreshError.transaction)
  clear_has_transaction();
  ::cockroach::roachpb::Transaction* temp = transaction_;
  transaction_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Transaction* TransactionRetryWithProtoRefreshError::mutable_transaction() {
  set_has_transaction();
  if (transaction_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Transaction>(GetArenaNoVirtual());
    transaction_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.TransactionRetryWithProtoRefreshError.transaction)
  return transaction_;
}
inline void TransactionRetryWithProtoRefreshError::set_allocated_transaction(::cockroach::roachpb::Transaction* transaction) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(transaction_);
  }
  if (transaction) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      transaction = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, transaction, submessage_arena);
    }
    set_has_transaction();
  } else {
    clear_has_transaction();
  }
  transaction_ = transaction;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.TransactionRetryWithProtoRefreshError.transaction)
}

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

// TxnAlreadyEncounteredErrorError

inline bool TxnAlreadyEncounteredErrorError::has_prev_error() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void TxnAlreadyEncounteredErrorError::set_has_prev_error() {
  _has_bits_[0] |= 0x00000001u;
}
inline void TxnAlreadyEncounteredErrorError::clear_has_prev_error() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void TxnAlreadyEncounteredErrorError::clear_prev_error() {
  prev_error_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_prev_error();
}
inline const ::std::string& TxnAlreadyEncounteredErrorError::prev_error() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.TxnAlreadyEncounteredErrorError.prev_error)
  return prev_error_.GetNoArena();
}
inline void TxnAlreadyEncounteredErrorError::set_prev_error(const ::std::string& value) {
  set_has_prev_error();
  prev_error_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.TxnAlreadyEncounteredErrorError.prev_error)
}
#if LANG_CXX11
inline void TxnAlreadyEncounteredErrorError::set_prev_error(::std::string&& value) {
  set_has_prev_error();
  prev_error_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.TxnAlreadyEncounteredErrorError.prev_error)
}
#endif
inline void TxnAlreadyEncounteredErrorError::set_prev_error(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_prev_error();
  prev_error_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.TxnAlreadyEncounteredErrorError.prev_error)
}
inline void TxnAlreadyEncounteredErrorError::set_prev_error(const char* value, size_t size) {
  set_has_prev_error();
  prev_error_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.TxnAlreadyEncounteredErrorError.prev_error)
}
inline ::std::string* TxnAlreadyEncounteredErrorError::mutable_prev_error() {
  set_has_prev_error();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.TxnAlreadyEncounteredErrorError.prev_error)
  return prev_error_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* TxnAlreadyEncounteredErrorError::release_prev_error() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.TxnAlreadyEncounteredErrorError.prev_error)
  if (!has_prev_error()) {
    return NULL;
  }
  clear_has_prev_error();
  return prev_error_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void TxnAlreadyEncounteredErrorError::set_allocated_prev_error(::std::string* prev_error) {
  if (prev_error != NULL) {
    set_has_prev_error();
  } else {
    clear_has_prev_error();
  }
  prev_error_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), prev_error);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.TxnAlreadyEncounteredErrorError.prev_error)
}

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

// IntegerOverflowError

inline bool IntegerOverflowError::has_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void IntegerOverflowError::set_has_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void IntegerOverflowError::clear_has_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void IntegerOverflowError::clear_key() {
  key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_key();
}
inline const ::std::string& IntegerOverflowError::key() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.IntegerOverflowError.key)
  return key_.GetNoArena();
}
inline void IntegerOverflowError::set_key(const ::std::string& value) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.IntegerOverflowError.key)
}
#if LANG_CXX11
inline void IntegerOverflowError::set_key(::std::string&& value) {
  set_has_key();
  key_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.IntegerOverflowError.key)
}
#endif
inline void IntegerOverflowError::set_key(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.IntegerOverflowError.key)
}
inline void IntegerOverflowError::set_key(const void* value, size_t size) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.IntegerOverflowError.key)
}
inline ::std::string* IntegerOverflowError::mutable_key() {
  set_has_key();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.IntegerOverflowError.key)
  return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* IntegerOverflowError::release_key() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.IntegerOverflowError.key)
  if (!has_key()) {
    return NULL;
  }
  clear_has_key();
  return key_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void IntegerOverflowError::set_allocated_key(::std::string* key) {
  if (key != NULL) {
    set_has_key();
  } else {
    clear_has_key();
  }
  key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.IntegerOverflowError.key)
}

inline bool IntegerOverflowError::has_current_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void IntegerOverflowError::set_has_current_value() {
  _has_bits_[0] |= 0x00000002u;
}
inline void IntegerOverflowError::clear_has_current_value() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void IntegerOverflowError::clear_current_value() {
  current_value_ = GOOGLE_LONGLONG(0);
  clear_has_current_value();
}
inline ::google::protobuf::int64 IntegerOverflowError::current_value() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.IntegerOverflowError.current_value)
  return current_value_;
}
inline void IntegerOverflowError::set_current_value(::google::protobuf::int64 value) {
  set_has_current_value();
  current_value_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.IntegerOverflowError.current_value)
}

inline bool IntegerOverflowError::has_increment_value() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void IntegerOverflowError::set_has_increment_value() {
  _has_bits_[0] |= 0x00000004u;
}
inline void IntegerOverflowError::clear_has_increment_value() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void IntegerOverflowError::clear_increment_value() {
  increment_value_ = GOOGLE_LONGLONG(0);
  clear_has_increment_value();
}
inline ::google::protobuf::int64 IntegerOverflowError::increment_value() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.IntegerOverflowError.increment_value)
  return increment_value_;
}
inline void IntegerOverflowError::set_increment_value(::google::protobuf::int64 value) {
  set_has_increment_value();
  increment_value_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.IntegerOverflowError.increment_value)
}

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

// BatchTimestampBeforeGCError

inline bool BatchTimestampBeforeGCError::has_timestamp() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BatchTimestampBeforeGCError::set_has_timestamp() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BatchTimestampBeforeGCError::clear_has_timestamp() {
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::cockroach::util::hlc::Timestamp& BatchTimestampBeforeGCError::_internal_timestamp() const {
  return *timestamp_;
}
inline const ::cockroach::util::hlc::Timestamp& BatchTimestampBeforeGCError::timestamp() const {
  const ::cockroach::util::hlc::Timestamp* p = timestamp_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.BatchTimestampBeforeGCError.Timestamp)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::util::hlc::Timestamp*>(
      &::cockroach::util::hlc::_Timestamp_default_instance_);
}
inline ::cockroach::util::hlc::Timestamp* BatchTimestampBeforeGCError::release_timestamp() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.BatchTimestampBeforeGCError.Timestamp)
  clear_has_timestamp();
  ::cockroach::util::hlc::Timestamp* temp = timestamp_;
  timestamp_ = NULL;
  return temp;
}
inline ::cockroach::util::hlc::Timestamp* BatchTimestampBeforeGCError::mutable_timestamp() {
  set_has_timestamp();
  if (timestamp_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::util::hlc::Timestamp>(GetArenaNoVirtual());
    timestamp_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.BatchTimestampBeforeGCError.Timestamp)
  return timestamp_;
}
inline void BatchTimestampBeforeGCError::set_allocated_timestamp(::cockroach::util::hlc::Timestamp* timestamp) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
  }
  if (timestamp) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      timestamp = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, timestamp, submessage_arena);
    }
    set_has_timestamp();
  } else {
    clear_has_timestamp();
  }
  timestamp_ = timestamp;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.BatchTimestampBeforeGCError.Timestamp)
}

inline bool BatchTimestampBeforeGCError::has_threshold() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BatchTimestampBeforeGCError::set_has_threshold() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BatchTimestampBeforeGCError::clear_has_threshold() {
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::cockroach::util::hlc::Timestamp& BatchTimestampBeforeGCError::_internal_threshold() const {
  return *threshold_;
}
inline const ::cockroach::util::hlc::Timestamp& BatchTimestampBeforeGCError::threshold() const {
  const ::cockroach::util::hlc::Timestamp* p = threshold_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.BatchTimestampBeforeGCError.Threshold)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::util::hlc::Timestamp*>(
      &::cockroach::util::hlc::_Timestamp_default_instance_);
}
inline ::cockroach::util::hlc::Timestamp* BatchTimestampBeforeGCError::release_threshold() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.BatchTimestampBeforeGCError.Threshold)
  clear_has_threshold();
  ::cockroach::util::hlc::Timestamp* temp = threshold_;
  threshold_ = NULL;
  return temp;
}
inline ::cockroach::util::hlc::Timestamp* BatchTimestampBeforeGCError::mutable_threshold() {
  set_has_threshold();
  if (threshold_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::util::hlc::Timestamp>(GetArenaNoVirtual());
    threshold_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.BatchTimestampBeforeGCError.Threshold)
  return threshold_;
}
inline void BatchTimestampBeforeGCError::set_allocated_threshold(::cockroach::util::hlc::Timestamp* threshold) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(threshold_);
  }
  if (threshold) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      threshold = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, threshold, submessage_arena);
    }
    set_has_threshold();
  } else {
    clear_has_threshold();
  }
  threshold_ = threshold;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.BatchTimestampBeforeGCError.Threshold)
}

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

// IntentMissingError

// optional .cockroach.roachpb.Intent wrong_intent = 1;
inline bool IntentMissingError::has_wrong_intent() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void IntentMissingError::set_has_wrong_intent() {
  _has_bits_[0] |= 0x00000002u;
}
inline void IntentMissingError::clear_has_wrong_intent() {
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::cockroach::roachpb::Intent& IntentMissingError::_internal_wrong_intent() const {
  return *wrong_intent_;
}
inline const ::cockroach::roachpb::Intent& IntentMissingError::wrong_intent() const {
  const ::cockroach::roachpb::Intent* p = wrong_intent_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.IntentMissingError.wrong_intent)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Intent*>(
      &::cockroach::roachpb::_Intent_default_instance_);
}
inline ::cockroach::roachpb::Intent* IntentMissingError::release_wrong_intent() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.IntentMissingError.wrong_intent)
  clear_has_wrong_intent();
  ::cockroach::roachpb::Intent* temp = wrong_intent_;
  wrong_intent_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Intent* IntentMissingError::mutable_wrong_intent() {
  set_has_wrong_intent();
  if (wrong_intent_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Intent>(GetArenaNoVirtual());
    wrong_intent_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.IntentMissingError.wrong_intent)
  return wrong_intent_;
}
inline void IntentMissingError::set_allocated_wrong_intent(::cockroach::roachpb::Intent* wrong_intent) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(wrong_intent_);
  }
  if (wrong_intent) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      wrong_intent = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, wrong_intent, submessage_arena);
    }
    set_has_wrong_intent();
  } else {
    clear_has_wrong_intent();
  }
  wrong_intent_ = wrong_intent;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.IntentMissingError.wrong_intent)
}

inline bool IntentMissingError::has_key() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void IntentMissingError::set_has_key() {
  _has_bits_[0] |= 0x00000001u;
}
inline void IntentMissingError::clear_has_key() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void IntentMissingError::clear_key() {
  key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_key();
}
inline const ::std::string& IntentMissingError::key() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.IntentMissingError.key)
  return key_.GetNoArena();
}
inline void IntentMissingError::set_key(const ::std::string& value) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.IntentMissingError.key)
}
#if LANG_CXX11
inline void IntentMissingError::set_key(::std::string&& value) {
  set_has_key();
  key_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.IntentMissingError.key)
}
#endif
inline void IntentMissingError::set_key(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.IntentMissingError.key)
}
inline void IntentMissingError::set_key(const void* value, size_t size) {
  set_has_key();
  key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.IntentMissingError.key)
}
inline ::std::string* IntentMissingError::mutable_key() {
  set_has_key();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.IntentMissingError.key)
  return key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* IntentMissingError::release_key() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.IntentMissingError.key)
  if (!has_key()) {
    return NULL;
  }
  clear_has_key();
  return key_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void IntentMissingError::set_allocated_key(::std::string* key) {
  if (key != NULL) {
    set_has_key();
  } else {
    clear_has_key();
  }
  key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.IntentMissingError.key)
}

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

// MergeInProgressError

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

// RangeFeedRetryError

inline bool RangeFeedRetryError::has_reason() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RangeFeedRetryError::set_has_reason() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RangeFeedRetryError::clear_has_reason() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RangeFeedRetryError::clear_reason() {
  reason_ = 0;
  clear_has_reason();
}
inline ::cockroach::roachpb::RangeFeedRetryError_Reason RangeFeedRetryError::reason() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.RangeFeedRetryError.reason)
  return static_cast< ::cockroach::roachpb::RangeFeedRetryError_Reason >(reason_);
}
inline void RangeFeedRetryError::set_reason(::cockroach::roachpb::RangeFeedRetryError_Reason value) {
  assert(::cockroach::roachpb::RangeFeedRetryError_Reason_IsValid(value));
  set_has_reason();
  reason_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.RangeFeedRetryError.reason)
}

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

// IndeterminateCommitError

inline bool IndeterminateCommitError::has_staging_txn() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void IndeterminateCommitError::set_has_staging_txn() {
  _has_bits_[0] |= 0x00000001u;
}
inline void IndeterminateCommitError::clear_has_staging_txn() {
  _has_bits_[0] &= ~0x00000001u;
}
inline const ::cockroach::roachpb::Transaction& IndeterminateCommitError::_internal_staging_txn() const {
  return *staging_txn_;
}
inline const ::cockroach::roachpb::Transaction& IndeterminateCommitError::staging_txn() const {
  const ::cockroach::roachpb::Transaction* p = staging_txn_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.IndeterminateCommitError.staging_txn)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Transaction*>(
      &::cockroach::roachpb::_Transaction_default_instance_);
}
inline ::cockroach::roachpb::Transaction* IndeterminateCommitError::release_staging_txn() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.IndeterminateCommitError.staging_txn)
  clear_has_staging_txn();
  ::cockroach::roachpb::Transaction* temp = staging_txn_;
  staging_txn_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Transaction* IndeterminateCommitError::mutable_staging_txn() {
  set_has_staging_txn();
  if (staging_txn_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Transaction>(GetArenaNoVirtual());
    staging_txn_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.IndeterminateCommitError.staging_txn)
  return staging_txn_;
}
inline void IndeterminateCommitError::set_allocated_staging_txn(::cockroach::roachpb::Transaction* staging_txn) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(staging_txn_);
  }
  if (staging_txn) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      staging_txn = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, staging_txn, submessage_arena);
    }
    set_has_staging_txn();
  } else {
    clear_has_staging_txn();
  }
  staging_txn_ = staging_txn;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.IndeterminateCommitError.staging_txn)
}

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

// ErrorDetail

// optional .cockroach.roachpb.NotLeaseHolderError not_lease_holder = 1;
inline bool ErrorDetail::has_not_lease_holder() const {
  return value_case() == kNotLeaseHolder;
}
inline void ErrorDetail::set_has_not_lease_holder() {
  _oneof_case_[0] = kNotLeaseHolder;
}
inline void ErrorDetail::clear_not_lease_holder() {
  if (has_not_lease_holder()) {
    delete value_.not_lease_holder_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::NotLeaseHolderError& ErrorDetail::_internal_not_lease_holder() const {
  return *value_.not_lease_holder_;
}
inline ::cockroach::roachpb::NotLeaseHolderError* ErrorDetail::release_not_lease_holder() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.not_lease_holder)
  if (has_not_lease_holder()) {
    clear_has_value();
      ::cockroach::roachpb::NotLeaseHolderError* temp = value_.not_lease_holder_;
    value_.not_lease_holder_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::NotLeaseHolderError& ErrorDetail::not_lease_holder() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.not_lease_holder)
  return has_not_lease_holder()
      ? *value_.not_lease_holder_
      : *reinterpret_cast< ::cockroach::roachpb::NotLeaseHolderError*>(&::cockroach::roachpb::_NotLeaseHolderError_default_instance_);
}
inline ::cockroach::roachpb::NotLeaseHolderError* ErrorDetail::mutable_not_lease_holder() {
  if (!has_not_lease_holder()) {
    clear_value();
    set_has_not_lease_holder();
    value_.not_lease_holder_ = CreateMaybeMessage< ::cockroach::roachpb::NotLeaseHolderError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.not_lease_holder)
  return value_.not_lease_holder_;
}

// optional .cockroach.roachpb.RangeNotFoundError range_not_found = 2;
inline bool ErrorDetail::has_range_not_found() const {
  return value_case() == kRangeNotFound;
}
inline void ErrorDetail::set_has_range_not_found() {
  _oneof_case_[0] = kRangeNotFound;
}
inline void ErrorDetail::clear_range_not_found() {
  if (has_range_not_found()) {
    delete value_.range_not_found_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::RangeNotFoundError& ErrorDetail::_internal_range_not_found() const {
  return *value_.range_not_found_;
}
inline ::cockroach::roachpb::RangeNotFoundError* ErrorDetail::release_range_not_found() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.range_not_found)
  if (has_range_not_found()) {
    clear_has_value();
      ::cockroach::roachpb::RangeNotFoundError* temp = value_.range_not_found_;
    value_.range_not_found_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::RangeNotFoundError& ErrorDetail::range_not_found() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.range_not_found)
  return has_range_not_found()
      ? *value_.range_not_found_
      : *reinterpret_cast< ::cockroach::roachpb::RangeNotFoundError*>(&::cockroach::roachpb::_RangeNotFoundError_default_instance_);
}
inline ::cockroach::roachpb::RangeNotFoundError* ErrorDetail::mutable_range_not_found() {
  if (!has_range_not_found()) {
    clear_value();
    set_has_range_not_found();
    value_.range_not_found_ = CreateMaybeMessage< ::cockroach::roachpb::RangeNotFoundError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.range_not_found)
  return value_.range_not_found_;
}

// optional .cockroach.roachpb.RangeKeyMismatchError range_key_mismatch = 3;
inline bool ErrorDetail::has_range_key_mismatch() const {
  return value_case() == kRangeKeyMismatch;
}
inline void ErrorDetail::set_has_range_key_mismatch() {
  _oneof_case_[0] = kRangeKeyMismatch;
}
inline void ErrorDetail::clear_range_key_mismatch() {
  if (has_range_key_mismatch()) {
    delete value_.range_key_mismatch_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::RangeKeyMismatchError& ErrorDetail::_internal_range_key_mismatch() const {
  return *value_.range_key_mismatch_;
}
inline ::cockroach::roachpb::RangeKeyMismatchError* ErrorDetail::release_range_key_mismatch() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.range_key_mismatch)
  if (has_range_key_mismatch()) {
    clear_has_value();
      ::cockroach::roachpb::RangeKeyMismatchError* temp = value_.range_key_mismatch_;
    value_.range_key_mismatch_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::RangeKeyMismatchError& ErrorDetail::range_key_mismatch() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.range_key_mismatch)
  return has_range_key_mismatch()
      ? *value_.range_key_mismatch_
      : *reinterpret_cast< ::cockroach::roachpb::RangeKeyMismatchError*>(&::cockroach::roachpb::_RangeKeyMismatchError_default_instance_);
}
inline ::cockroach::roachpb::RangeKeyMismatchError* ErrorDetail::mutable_range_key_mismatch() {
  if (!has_range_key_mismatch()) {
    clear_value();
    set_has_range_key_mismatch();
    value_.range_key_mismatch_ = CreateMaybeMessage< ::cockroach::roachpb::RangeKeyMismatchError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.range_key_mismatch)
  return value_.range_key_mismatch_;
}

// optional .cockroach.roachpb.ReadWithinUncertaintyIntervalError read_within_uncertainty_interval = 4;
inline bool ErrorDetail::has_read_within_uncertainty_interval() const {
  return value_case() == kReadWithinUncertaintyInterval;
}
inline void ErrorDetail::set_has_read_within_uncertainty_interval() {
  _oneof_case_[0] = kReadWithinUncertaintyInterval;
}
inline void ErrorDetail::clear_read_within_uncertainty_interval() {
  if (has_read_within_uncertainty_interval()) {
    delete value_.read_within_uncertainty_interval_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::ReadWithinUncertaintyIntervalError& ErrorDetail::_internal_read_within_uncertainty_interval() const {
  return *value_.read_within_uncertainty_interval_;
}
inline ::cockroach::roachpb::ReadWithinUncertaintyIntervalError* ErrorDetail::release_read_within_uncertainty_interval() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.read_within_uncertainty_interval)
  if (has_read_within_uncertainty_interval()) {
    clear_has_value();
      ::cockroach::roachpb::ReadWithinUncertaintyIntervalError* temp = value_.read_within_uncertainty_interval_;
    value_.read_within_uncertainty_interval_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::ReadWithinUncertaintyIntervalError& ErrorDetail::read_within_uncertainty_interval() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.read_within_uncertainty_interval)
  return has_read_within_uncertainty_interval()
      ? *value_.read_within_uncertainty_interval_
      : *reinterpret_cast< ::cockroach::roachpb::ReadWithinUncertaintyIntervalError*>(&::cockroach::roachpb::_ReadWithinUncertaintyIntervalError_default_instance_);
}
inline ::cockroach::roachpb::ReadWithinUncertaintyIntervalError* ErrorDetail::mutable_read_within_uncertainty_interval() {
  if (!has_read_within_uncertainty_interval()) {
    clear_value();
    set_has_read_within_uncertainty_interval();
    value_.read_within_uncertainty_interval_ = CreateMaybeMessage< ::cockroach::roachpb::ReadWithinUncertaintyIntervalError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.read_within_uncertainty_interval)
  return value_.read_within_uncertainty_interval_;
}

// optional .cockroach.roachpb.TransactionAbortedError transaction_aborted = 5;
inline bool ErrorDetail::has_transaction_aborted() const {
  return value_case() == kTransactionAborted;
}
inline void ErrorDetail::set_has_transaction_aborted() {
  _oneof_case_[0] = kTransactionAborted;
}
inline void ErrorDetail::clear_transaction_aborted() {
  if (has_transaction_aborted()) {
    delete value_.transaction_aborted_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::TransactionAbortedError& ErrorDetail::_internal_transaction_aborted() const {
  return *value_.transaction_aborted_;
}
inline ::cockroach::roachpb::TransactionAbortedError* ErrorDetail::release_transaction_aborted() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.transaction_aborted)
  if (has_transaction_aborted()) {
    clear_has_value();
      ::cockroach::roachpb::TransactionAbortedError* temp = value_.transaction_aborted_;
    value_.transaction_aborted_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::TransactionAbortedError& ErrorDetail::transaction_aborted() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.transaction_aborted)
  return has_transaction_aborted()
      ? *value_.transaction_aborted_
      : *reinterpret_cast< ::cockroach::roachpb::TransactionAbortedError*>(&::cockroach::roachpb::_TransactionAbortedError_default_instance_);
}
inline ::cockroach::roachpb::TransactionAbortedError* ErrorDetail::mutable_transaction_aborted() {
  if (!has_transaction_aborted()) {
    clear_value();
    set_has_transaction_aborted();
    value_.transaction_aborted_ = CreateMaybeMessage< ::cockroach::roachpb::TransactionAbortedError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.transaction_aborted)
  return value_.transaction_aborted_;
}

// optional .cockroach.roachpb.TransactionPushError transaction_push = 6;
inline bool ErrorDetail::has_transaction_push() const {
  return value_case() == kTransactionPush;
}
inline void ErrorDetail::set_has_transaction_push() {
  _oneof_case_[0] = kTransactionPush;
}
inline void ErrorDetail::clear_transaction_push() {
  if (has_transaction_push()) {
    delete value_.transaction_push_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::TransactionPushError& ErrorDetail::_internal_transaction_push() const {
  return *value_.transaction_push_;
}
inline ::cockroach::roachpb::TransactionPushError* ErrorDetail::release_transaction_push() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.transaction_push)
  if (has_transaction_push()) {
    clear_has_value();
      ::cockroach::roachpb::TransactionPushError* temp = value_.transaction_push_;
    value_.transaction_push_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::TransactionPushError& ErrorDetail::transaction_push() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.transaction_push)
  return has_transaction_push()
      ? *value_.transaction_push_
      : *reinterpret_cast< ::cockroach::roachpb::TransactionPushError*>(&::cockroach::roachpb::_TransactionPushError_default_instance_);
}
inline ::cockroach::roachpb::TransactionPushError* ErrorDetail::mutable_transaction_push() {
  if (!has_transaction_push()) {
    clear_value();
    set_has_transaction_push();
    value_.transaction_push_ = CreateMaybeMessage< ::cockroach::roachpb::TransactionPushError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.transaction_push)
  return value_.transaction_push_;
}

// optional .cockroach.roachpb.TransactionRetryError transaction_retry = 7;
inline bool ErrorDetail::has_transaction_retry() const {
  return value_case() == kTransactionRetry;
}
inline void ErrorDetail::set_has_transaction_retry() {
  _oneof_case_[0] = kTransactionRetry;
}
inline void ErrorDetail::clear_transaction_retry() {
  if (has_transaction_retry()) {
    delete value_.transaction_retry_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::TransactionRetryError& ErrorDetail::_internal_transaction_retry() const {
  return *value_.transaction_retry_;
}
inline ::cockroach::roachpb::TransactionRetryError* ErrorDetail::release_transaction_retry() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.transaction_retry)
  if (has_transaction_retry()) {
    clear_has_value();
      ::cockroach::roachpb::TransactionRetryError* temp = value_.transaction_retry_;
    value_.transaction_retry_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::TransactionRetryError& ErrorDetail::transaction_retry() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.transaction_retry)
  return has_transaction_retry()
      ? *value_.transaction_retry_
      : *reinterpret_cast< ::cockroach::roachpb::TransactionRetryError*>(&::cockroach::roachpb::_TransactionRetryError_default_instance_);
}
inline ::cockroach::roachpb::TransactionRetryError* ErrorDetail::mutable_transaction_retry() {
  if (!has_transaction_retry()) {
    clear_value();
    set_has_transaction_retry();
    value_.transaction_retry_ = CreateMaybeMessage< ::cockroach::roachpb::TransactionRetryError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.transaction_retry)
  return value_.transaction_retry_;
}

// optional .cockroach.roachpb.TransactionStatusError transaction_status = 8;
inline bool ErrorDetail::has_transaction_status() const {
  return value_case() == kTransactionStatus;
}
inline void ErrorDetail::set_has_transaction_status() {
  _oneof_case_[0] = kTransactionStatus;
}
inline void ErrorDetail::clear_transaction_status() {
  if (has_transaction_status()) {
    delete value_.transaction_status_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::TransactionStatusError& ErrorDetail::_internal_transaction_status() const {
  return *value_.transaction_status_;
}
inline ::cockroach::roachpb::TransactionStatusError* ErrorDetail::release_transaction_status() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.transaction_status)
  if (has_transaction_status()) {
    clear_has_value();
      ::cockroach::roachpb::TransactionStatusError* temp = value_.transaction_status_;
    value_.transaction_status_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::TransactionStatusError& ErrorDetail::transaction_status() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.transaction_status)
  return has_transaction_status()
      ? *value_.transaction_status_
      : *reinterpret_cast< ::cockroach::roachpb::TransactionStatusError*>(&::cockroach::roachpb::_TransactionStatusError_default_instance_);
}
inline ::cockroach::roachpb::TransactionStatusError* ErrorDetail::mutable_transaction_status() {
  if (!has_transaction_status()) {
    clear_value();
    set_has_transaction_status();
    value_.transaction_status_ = CreateMaybeMessage< ::cockroach::roachpb::TransactionStatusError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.transaction_status)
  return value_.transaction_status_;
}

// optional .cockroach.roachpb.WriteIntentError write_intent = 9;
inline bool ErrorDetail::has_write_intent() const {
  return value_case() == kWriteIntent;
}
inline void ErrorDetail::set_has_write_intent() {
  _oneof_case_[0] = kWriteIntent;
}
inline void ErrorDetail::clear_write_intent() {
  if (has_write_intent()) {
    delete value_.write_intent_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::WriteIntentError& ErrorDetail::_internal_write_intent() const {
  return *value_.write_intent_;
}
inline ::cockroach::roachpb::WriteIntentError* ErrorDetail::release_write_intent() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.write_intent)
  if (has_write_intent()) {
    clear_has_value();
      ::cockroach::roachpb::WriteIntentError* temp = value_.write_intent_;
    value_.write_intent_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::WriteIntentError& ErrorDetail::write_intent() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.write_intent)
  return has_write_intent()
      ? *value_.write_intent_
      : *reinterpret_cast< ::cockroach::roachpb::WriteIntentError*>(&::cockroach::roachpb::_WriteIntentError_default_instance_);
}
inline ::cockroach::roachpb::WriteIntentError* ErrorDetail::mutable_write_intent() {
  if (!has_write_intent()) {
    clear_value();
    set_has_write_intent();
    value_.write_intent_ = CreateMaybeMessage< ::cockroach::roachpb::WriteIntentError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.write_intent)
  return value_.write_intent_;
}

// optional .cockroach.roachpb.WriteTooOldError write_too_old = 10;
inline bool ErrorDetail::has_write_too_old() const {
  return value_case() == kWriteTooOld;
}
inline void ErrorDetail::set_has_write_too_old() {
  _oneof_case_[0] = kWriteTooOld;
}
inline void ErrorDetail::clear_write_too_old() {
  if (has_write_too_old()) {
    delete value_.write_too_old_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::WriteTooOldError& ErrorDetail::_internal_write_too_old() const {
  return *value_.write_too_old_;
}
inline ::cockroach::roachpb::WriteTooOldError* ErrorDetail::release_write_too_old() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.write_too_old)
  if (has_write_too_old()) {
    clear_has_value();
      ::cockroach::roachpb::WriteTooOldError* temp = value_.write_too_old_;
    value_.write_too_old_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::WriteTooOldError& ErrorDetail::write_too_old() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.write_too_old)
  return has_write_too_old()
      ? *value_.write_too_old_
      : *reinterpret_cast< ::cockroach::roachpb::WriteTooOldError*>(&::cockroach::roachpb::_WriteTooOldError_default_instance_);
}
inline ::cockroach::roachpb::WriteTooOldError* ErrorDetail::mutable_write_too_old() {
  if (!has_write_too_old()) {
    clear_value();
    set_has_write_too_old();
    value_.write_too_old_ = CreateMaybeMessage< ::cockroach::roachpb::WriteTooOldError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.write_too_old)
  return value_.write_too_old_;
}

// optional .cockroach.roachpb.OpRequiresTxnError op_requires_txn = 11;
inline bool ErrorDetail::has_op_requires_txn() const {
  return value_case() == kOpRequiresTxn;
}
inline void ErrorDetail::set_has_op_requires_txn() {
  _oneof_case_[0] = kOpRequiresTxn;
}
inline void ErrorDetail::clear_op_requires_txn() {
  if (has_op_requires_txn()) {
    delete value_.op_requires_txn_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::OpRequiresTxnError& ErrorDetail::_internal_op_requires_txn() const {
  return *value_.op_requires_txn_;
}
inline ::cockroach::roachpb::OpRequiresTxnError* ErrorDetail::release_op_requires_txn() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.op_requires_txn)
  if (has_op_requires_txn()) {
    clear_has_value();
      ::cockroach::roachpb::OpRequiresTxnError* temp = value_.op_requires_txn_;
    value_.op_requires_txn_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::OpRequiresTxnError& ErrorDetail::op_requires_txn() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.op_requires_txn)
  return has_op_requires_txn()
      ? *value_.op_requires_txn_
      : *reinterpret_cast< ::cockroach::roachpb::OpRequiresTxnError*>(&::cockroach::roachpb::_OpRequiresTxnError_default_instance_);
}
inline ::cockroach::roachpb::OpRequiresTxnError* ErrorDetail::mutable_op_requires_txn() {
  if (!has_op_requires_txn()) {
    clear_value();
    set_has_op_requires_txn();
    value_.op_requires_txn_ = CreateMaybeMessage< ::cockroach::roachpb::OpRequiresTxnError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.op_requires_txn)
  return value_.op_requires_txn_;
}

// optional .cockroach.roachpb.ConditionFailedError condition_failed = 12;
inline bool ErrorDetail::has_condition_failed() const {
  return value_case() == kConditionFailed;
}
inline void ErrorDetail::set_has_condition_failed() {
  _oneof_case_[0] = kConditionFailed;
}
inline void ErrorDetail::clear_condition_failed() {
  if (has_condition_failed()) {
    delete value_.condition_failed_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::ConditionFailedError& ErrorDetail::_internal_condition_failed() const {
  return *value_.condition_failed_;
}
inline ::cockroach::roachpb::ConditionFailedError* ErrorDetail::release_condition_failed() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.condition_failed)
  if (has_condition_failed()) {
    clear_has_value();
      ::cockroach::roachpb::ConditionFailedError* temp = value_.condition_failed_;
    value_.condition_failed_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::ConditionFailedError& ErrorDetail::condition_failed() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.condition_failed)
  return has_condition_failed()
      ? *value_.condition_failed_
      : *reinterpret_cast< ::cockroach::roachpb::ConditionFailedError*>(&::cockroach::roachpb::_ConditionFailedError_default_instance_);
}
inline ::cockroach::roachpb::ConditionFailedError* ErrorDetail::mutable_condition_failed() {
  if (!has_condition_failed()) {
    clear_value();
    set_has_condition_failed();
    value_.condition_failed_ = CreateMaybeMessage< ::cockroach::roachpb::ConditionFailedError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.condition_failed)
  return value_.condition_failed_;
}

// optional .cockroach.roachpb.LeaseRejectedError lease_rejected = 13;
inline bool ErrorDetail::has_lease_rejected() const {
  return value_case() == kLeaseRejected;
}
inline void ErrorDetail::set_has_lease_rejected() {
  _oneof_case_[0] = kLeaseRejected;
}
inline void ErrorDetail::clear_lease_rejected() {
  if (has_lease_rejected()) {
    delete value_.lease_rejected_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::LeaseRejectedError& ErrorDetail::_internal_lease_rejected() const {
  return *value_.lease_rejected_;
}
inline ::cockroach::roachpb::LeaseRejectedError* ErrorDetail::release_lease_rejected() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.lease_rejected)
  if (has_lease_rejected()) {
    clear_has_value();
      ::cockroach::roachpb::LeaseRejectedError* temp = value_.lease_rejected_;
    value_.lease_rejected_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::LeaseRejectedError& ErrorDetail::lease_rejected() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.lease_rejected)
  return has_lease_rejected()
      ? *value_.lease_rejected_
      : *reinterpret_cast< ::cockroach::roachpb::LeaseRejectedError*>(&::cockroach::roachpb::_LeaseRejectedError_default_instance_);
}
inline ::cockroach::roachpb::LeaseRejectedError* ErrorDetail::mutable_lease_rejected() {
  if (!has_lease_rejected()) {
    clear_value();
    set_has_lease_rejected();
    value_.lease_rejected_ = CreateMaybeMessage< ::cockroach::roachpb::LeaseRejectedError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.lease_rejected)
  return value_.lease_rejected_;
}

// optional .cockroach.roachpb.NodeUnavailableError node_unavailable = 14;
inline bool ErrorDetail::has_node_unavailable() const {
  return value_case() == kNodeUnavailable;
}
inline void ErrorDetail::set_has_node_unavailable() {
  _oneof_case_[0] = kNodeUnavailable;
}
inline void ErrorDetail::clear_node_unavailable() {
  if (has_node_unavailable()) {
    delete value_.node_unavailable_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::NodeUnavailableError& ErrorDetail::_internal_node_unavailable() const {
  return *value_.node_unavailable_;
}
inline ::cockroach::roachpb::NodeUnavailableError* ErrorDetail::release_node_unavailable() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.node_unavailable)
  if (has_node_unavailable()) {
    clear_has_value();
      ::cockroach::roachpb::NodeUnavailableError* temp = value_.node_unavailable_;
    value_.node_unavailable_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::NodeUnavailableError& ErrorDetail::node_unavailable() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.node_unavailable)
  return has_node_unavailable()
      ? *value_.node_unavailable_
      : *reinterpret_cast< ::cockroach::roachpb::NodeUnavailableError*>(&::cockroach::roachpb::_NodeUnavailableError_default_instance_);
}
inline ::cockroach::roachpb::NodeUnavailableError* ErrorDetail::mutable_node_unavailable() {
  if (!has_node_unavailable()) {
    clear_value();
    set_has_node_unavailable();
    value_.node_unavailable_ = CreateMaybeMessage< ::cockroach::roachpb::NodeUnavailableError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.node_unavailable)
  return value_.node_unavailable_;
}

// optional .cockroach.roachpb.SendError send = 15;
inline bool ErrorDetail::has_send() const {
  return value_case() == kSend;
}
inline void ErrorDetail::set_has_send() {
  _oneof_case_[0] = kSend;
}
inline void ErrorDetail::clear_send() {
  if (has_send()) {
    delete value_.send_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::SendError& ErrorDetail::_internal_send() const {
  return *value_.send_;
}
inline ::cockroach::roachpb::SendError* ErrorDetail::release_send() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.send)
  if (has_send()) {
    clear_has_value();
      ::cockroach::roachpb::SendError* temp = value_.send_;
    value_.send_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::SendError& ErrorDetail::send() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.send)
  return has_send()
      ? *value_.send_
      : *reinterpret_cast< ::cockroach::roachpb::SendError*>(&::cockroach::roachpb::_SendError_default_instance_);
}
inline ::cockroach::roachpb::SendError* ErrorDetail::mutable_send() {
  if (!has_send()) {
    clear_value();
    set_has_send();
    value_.send_ = CreateMaybeMessage< ::cockroach::roachpb::SendError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.send)
  return value_.send_;
}

// optional .cockroach.roachpb.RaftGroupDeletedError raft_group_deleted = 16;
inline bool ErrorDetail::has_raft_group_deleted() const {
  return value_case() == kRaftGroupDeleted;
}
inline void ErrorDetail::set_has_raft_group_deleted() {
  _oneof_case_[0] = kRaftGroupDeleted;
}
inline void ErrorDetail::clear_raft_group_deleted() {
  if (has_raft_group_deleted()) {
    delete value_.raft_group_deleted_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::RaftGroupDeletedError& ErrorDetail::_internal_raft_group_deleted() const {
  return *value_.raft_group_deleted_;
}
inline ::cockroach::roachpb::RaftGroupDeletedError* ErrorDetail::release_raft_group_deleted() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.raft_group_deleted)
  if (has_raft_group_deleted()) {
    clear_has_value();
      ::cockroach::roachpb::RaftGroupDeletedError* temp = value_.raft_group_deleted_;
    value_.raft_group_deleted_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::RaftGroupDeletedError& ErrorDetail::raft_group_deleted() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.raft_group_deleted)
  return has_raft_group_deleted()
      ? *value_.raft_group_deleted_
      : *reinterpret_cast< ::cockroach::roachpb::RaftGroupDeletedError*>(&::cockroach::roachpb::_RaftGroupDeletedError_default_instance_);
}
inline ::cockroach::roachpb::RaftGroupDeletedError* ErrorDetail::mutable_raft_group_deleted() {
  if (!has_raft_group_deleted()) {
    clear_value();
    set_has_raft_group_deleted();
    value_.raft_group_deleted_ = CreateMaybeMessage< ::cockroach::roachpb::RaftGroupDeletedError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.raft_group_deleted)
  return value_.raft_group_deleted_;
}

// optional .cockroach.roachpb.ReplicaCorruptionError replica_corruption = 17;
inline bool ErrorDetail::has_replica_corruption() const {
  return value_case() == kReplicaCorruption;
}
inline void ErrorDetail::set_has_replica_corruption() {
  _oneof_case_[0] = kReplicaCorruption;
}
inline void ErrorDetail::clear_replica_corruption() {
  if (has_replica_corruption()) {
    delete value_.replica_corruption_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::ReplicaCorruptionError& ErrorDetail::_internal_replica_corruption() const {
  return *value_.replica_corruption_;
}
inline ::cockroach::roachpb::ReplicaCorruptionError* ErrorDetail::release_replica_corruption() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.replica_corruption)
  if (has_replica_corruption()) {
    clear_has_value();
      ::cockroach::roachpb::ReplicaCorruptionError* temp = value_.replica_corruption_;
    value_.replica_corruption_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::ReplicaCorruptionError& ErrorDetail::replica_corruption() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.replica_corruption)
  return has_replica_corruption()
      ? *value_.replica_corruption_
      : *reinterpret_cast< ::cockroach::roachpb::ReplicaCorruptionError*>(&::cockroach::roachpb::_ReplicaCorruptionError_default_instance_);
}
inline ::cockroach::roachpb::ReplicaCorruptionError* ErrorDetail::mutable_replica_corruption() {
  if (!has_replica_corruption()) {
    clear_value();
    set_has_replica_corruption();
    value_.replica_corruption_ = CreateMaybeMessage< ::cockroach::roachpb::ReplicaCorruptionError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.replica_corruption)
  return value_.replica_corruption_;
}

// optional .cockroach.roachpb.ReplicaTooOldError replica_too_old = 18;
inline bool ErrorDetail::has_replica_too_old() const {
  return value_case() == kReplicaTooOld;
}
inline void ErrorDetail::set_has_replica_too_old() {
  _oneof_case_[0] = kReplicaTooOld;
}
inline void ErrorDetail::clear_replica_too_old() {
  if (has_replica_too_old()) {
    delete value_.replica_too_old_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::ReplicaTooOldError& ErrorDetail::_internal_replica_too_old() const {
  return *value_.replica_too_old_;
}
inline ::cockroach::roachpb::ReplicaTooOldError* ErrorDetail::release_replica_too_old() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.replica_too_old)
  if (has_replica_too_old()) {
    clear_has_value();
      ::cockroach::roachpb::ReplicaTooOldError* temp = value_.replica_too_old_;
    value_.replica_too_old_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::ReplicaTooOldError& ErrorDetail::replica_too_old() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.replica_too_old)
  return has_replica_too_old()
      ? *value_.replica_too_old_
      : *reinterpret_cast< ::cockroach::roachpb::ReplicaTooOldError*>(&::cockroach::roachpb::_ReplicaTooOldError_default_instance_);
}
inline ::cockroach::roachpb::ReplicaTooOldError* ErrorDetail::mutable_replica_too_old() {
  if (!has_replica_too_old()) {
    clear_value();
    set_has_replica_too_old();
    value_.replica_too_old_ = CreateMaybeMessage< ::cockroach::roachpb::ReplicaTooOldError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.replica_too_old)
  return value_.replica_too_old_;
}

// optional .cockroach.roachpb.AmbiguousResultError ambiguous_result = 26;
inline bool ErrorDetail::has_ambiguous_result() const {
  return value_case() == kAmbiguousResult;
}
inline void ErrorDetail::set_has_ambiguous_result() {
  _oneof_case_[0] = kAmbiguousResult;
}
inline void ErrorDetail::clear_ambiguous_result() {
  if (has_ambiguous_result()) {
    delete value_.ambiguous_result_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::AmbiguousResultError& ErrorDetail::_internal_ambiguous_result() const {
  return *value_.ambiguous_result_;
}
inline ::cockroach::roachpb::AmbiguousResultError* ErrorDetail::release_ambiguous_result() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.ambiguous_result)
  if (has_ambiguous_result()) {
    clear_has_value();
      ::cockroach::roachpb::AmbiguousResultError* temp = value_.ambiguous_result_;
    value_.ambiguous_result_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::AmbiguousResultError& ErrorDetail::ambiguous_result() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.ambiguous_result)
  return has_ambiguous_result()
      ? *value_.ambiguous_result_
      : *reinterpret_cast< ::cockroach::roachpb::AmbiguousResultError*>(&::cockroach::roachpb::_AmbiguousResultError_default_instance_);
}
inline ::cockroach::roachpb::AmbiguousResultError* ErrorDetail::mutable_ambiguous_result() {
  if (!has_ambiguous_result()) {
    clear_value();
    set_has_ambiguous_result();
    value_.ambiguous_result_ = CreateMaybeMessage< ::cockroach::roachpb::AmbiguousResultError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.ambiguous_result)
  return value_.ambiguous_result_;
}

// optional .cockroach.roachpb.StoreNotFoundError store_not_found = 27;
inline bool ErrorDetail::has_store_not_found() const {
  return value_case() == kStoreNotFound;
}
inline void ErrorDetail::set_has_store_not_found() {
  _oneof_case_[0] = kStoreNotFound;
}
inline void ErrorDetail::clear_store_not_found() {
  if (has_store_not_found()) {
    delete value_.store_not_found_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::StoreNotFoundError& ErrorDetail::_internal_store_not_found() const {
  return *value_.store_not_found_;
}
inline ::cockroach::roachpb::StoreNotFoundError* ErrorDetail::release_store_not_found() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.store_not_found)
  if (has_store_not_found()) {
    clear_has_value();
      ::cockroach::roachpb::StoreNotFoundError* temp = value_.store_not_found_;
    value_.store_not_found_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::StoreNotFoundError& ErrorDetail::store_not_found() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.store_not_found)
  return has_store_not_found()
      ? *value_.store_not_found_
      : *reinterpret_cast< ::cockroach::roachpb::StoreNotFoundError*>(&::cockroach::roachpb::_StoreNotFoundError_default_instance_);
}
inline ::cockroach::roachpb::StoreNotFoundError* ErrorDetail::mutable_store_not_found() {
  if (!has_store_not_found()) {
    clear_value();
    set_has_store_not_found();
    value_.store_not_found_ = CreateMaybeMessage< ::cockroach::roachpb::StoreNotFoundError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.store_not_found)
  return value_.store_not_found_;
}

// optional .cockroach.roachpb.TransactionRetryWithProtoRefreshError transaction_retry_with_proto_refresh = 28;
inline bool ErrorDetail::has_transaction_retry_with_proto_refresh() const {
  return value_case() == kTransactionRetryWithProtoRefresh;
}
inline void ErrorDetail::set_has_transaction_retry_with_proto_refresh() {
  _oneof_case_[0] = kTransactionRetryWithProtoRefresh;
}
inline void ErrorDetail::clear_transaction_retry_with_proto_refresh() {
  if (has_transaction_retry_with_proto_refresh()) {
    delete value_.transaction_retry_with_proto_refresh_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::TransactionRetryWithProtoRefreshError& ErrorDetail::_internal_transaction_retry_with_proto_refresh() const {
  return *value_.transaction_retry_with_proto_refresh_;
}
inline ::cockroach::roachpb::TransactionRetryWithProtoRefreshError* ErrorDetail::release_transaction_retry_with_proto_refresh() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.transaction_retry_with_proto_refresh)
  if (has_transaction_retry_with_proto_refresh()) {
    clear_has_value();
      ::cockroach::roachpb::TransactionRetryWithProtoRefreshError* temp = value_.transaction_retry_with_proto_refresh_;
    value_.transaction_retry_with_proto_refresh_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::TransactionRetryWithProtoRefreshError& ErrorDetail::transaction_retry_with_proto_refresh() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.transaction_retry_with_proto_refresh)
  return has_transaction_retry_with_proto_refresh()
      ? *value_.transaction_retry_with_proto_refresh_
      : *reinterpret_cast< ::cockroach::roachpb::TransactionRetryWithProtoRefreshError*>(&::cockroach::roachpb::_TransactionRetryWithProtoRefreshError_default_instance_);
}
inline ::cockroach::roachpb::TransactionRetryWithProtoRefreshError* ErrorDetail::mutable_transaction_retry_with_proto_refresh() {
  if (!has_transaction_retry_with_proto_refresh()) {
    clear_value();
    set_has_transaction_retry_with_proto_refresh();
    value_.transaction_retry_with_proto_refresh_ = CreateMaybeMessage< ::cockroach::roachpb::TransactionRetryWithProtoRefreshError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.transaction_retry_with_proto_refresh)
  return value_.transaction_retry_with_proto_refresh_;
}

// optional .cockroach.roachpb.IntegerOverflowError integer_overflow = 31;
inline bool ErrorDetail::has_integer_overflow() const {
  return value_case() == kIntegerOverflow;
}
inline void ErrorDetail::set_has_integer_overflow() {
  _oneof_case_[0] = kIntegerOverflow;
}
inline void ErrorDetail::clear_integer_overflow() {
  if (has_integer_overflow()) {
    delete value_.integer_overflow_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::IntegerOverflowError& ErrorDetail::_internal_integer_overflow() const {
  return *value_.integer_overflow_;
}
inline ::cockroach::roachpb::IntegerOverflowError* ErrorDetail::release_integer_overflow() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.integer_overflow)
  if (has_integer_overflow()) {
    clear_has_value();
      ::cockroach::roachpb::IntegerOverflowError* temp = value_.integer_overflow_;
    value_.integer_overflow_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::IntegerOverflowError& ErrorDetail::integer_overflow() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.integer_overflow)
  return has_integer_overflow()
      ? *value_.integer_overflow_
      : *reinterpret_cast< ::cockroach::roachpb::IntegerOverflowError*>(&::cockroach::roachpb::_IntegerOverflowError_default_instance_);
}
inline ::cockroach::roachpb::IntegerOverflowError* ErrorDetail::mutable_integer_overflow() {
  if (!has_integer_overflow()) {
    clear_value();
    set_has_integer_overflow();
    value_.integer_overflow_ = CreateMaybeMessage< ::cockroach::roachpb::IntegerOverflowError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.integer_overflow)
  return value_.integer_overflow_;
}

// optional .cockroach.roachpb.UnsupportedRequestError unsupported_request = 32;
inline bool ErrorDetail::has_unsupported_request() const {
  return value_case() == kUnsupportedRequest;
}
inline void ErrorDetail::set_has_unsupported_request() {
  _oneof_case_[0] = kUnsupportedRequest;
}
inline void ErrorDetail::clear_unsupported_request() {
  if (has_unsupported_request()) {
    delete value_.unsupported_request_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::UnsupportedRequestError& ErrorDetail::_internal_unsupported_request() const {
  return *value_.unsupported_request_;
}
inline ::cockroach::roachpb::UnsupportedRequestError* ErrorDetail::release_unsupported_request() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.unsupported_request)
  if (has_unsupported_request()) {
    clear_has_value();
      ::cockroach::roachpb::UnsupportedRequestError* temp = value_.unsupported_request_;
    value_.unsupported_request_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::UnsupportedRequestError& ErrorDetail::unsupported_request() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.unsupported_request)
  return has_unsupported_request()
      ? *value_.unsupported_request_
      : *reinterpret_cast< ::cockroach::roachpb::UnsupportedRequestError*>(&::cockroach::roachpb::_UnsupportedRequestError_default_instance_);
}
inline ::cockroach::roachpb::UnsupportedRequestError* ErrorDetail::mutable_unsupported_request() {
  if (!has_unsupported_request()) {
    clear_value();
    set_has_unsupported_request();
    value_.unsupported_request_ = CreateMaybeMessage< ::cockroach::roachpb::UnsupportedRequestError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.unsupported_request)
  return value_.unsupported_request_;
}

// optional .cockroach.roachpb.BatchTimestampBeforeGCError timestamp_before = 34;
inline bool ErrorDetail::has_timestamp_before() const {
  return value_case() == kTimestampBefore;
}
inline void ErrorDetail::set_has_timestamp_before() {
  _oneof_case_[0] = kTimestampBefore;
}
inline void ErrorDetail::clear_timestamp_before() {
  if (has_timestamp_before()) {
    delete value_.timestamp_before_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::BatchTimestampBeforeGCError& ErrorDetail::_internal_timestamp_before() const {
  return *value_.timestamp_before_;
}
inline ::cockroach::roachpb::BatchTimestampBeforeGCError* ErrorDetail::release_timestamp_before() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.timestamp_before)
  if (has_timestamp_before()) {
    clear_has_value();
      ::cockroach::roachpb::BatchTimestampBeforeGCError* temp = value_.timestamp_before_;
    value_.timestamp_before_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::BatchTimestampBeforeGCError& ErrorDetail::timestamp_before() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.timestamp_before)
  return has_timestamp_before()
      ? *value_.timestamp_before_
      : *reinterpret_cast< ::cockroach::roachpb::BatchTimestampBeforeGCError*>(&::cockroach::roachpb::_BatchTimestampBeforeGCError_default_instance_);
}
inline ::cockroach::roachpb::BatchTimestampBeforeGCError* ErrorDetail::mutable_timestamp_before() {
  if (!has_timestamp_before()) {
    clear_value();
    set_has_timestamp_before();
    value_.timestamp_before_ = CreateMaybeMessage< ::cockroach::roachpb::BatchTimestampBeforeGCError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.timestamp_before)
  return value_.timestamp_before_;
}

// optional .cockroach.roachpb.TxnAlreadyEncounteredErrorError txn_already_encountered_error = 35;
inline bool ErrorDetail::has_txn_already_encountered_error() const {
  return value_case() == kTxnAlreadyEncounteredError;
}
inline void ErrorDetail::set_has_txn_already_encountered_error() {
  _oneof_case_[0] = kTxnAlreadyEncounteredError;
}
inline void ErrorDetail::clear_txn_already_encountered_error() {
  if (has_txn_already_encountered_error()) {
    delete value_.txn_already_encountered_error_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::TxnAlreadyEncounteredErrorError& ErrorDetail::_internal_txn_already_encountered_error() const {
  return *value_.txn_already_encountered_error_;
}
inline ::cockroach::roachpb::TxnAlreadyEncounteredErrorError* ErrorDetail::release_txn_already_encountered_error() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.txn_already_encountered_error)
  if (has_txn_already_encountered_error()) {
    clear_has_value();
      ::cockroach::roachpb::TxnAlreadyEncounteredErrorError* temp = value_.txn_already_encountered_error_;
    value_.txn_already_encountered_error_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::TxnAlreadyEncounteredErrorError& ErrorDetail::txn_already_encountered_error() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.txn_already_encountered_error)
  return has_txn_already_encountered_error()
      ? *value_.txn_already_encountered_error_
      : *reinterpret_cast< ::cockroach::roachpb::TxnAlreadyEncounteredErrorError*>(&::cockroach::roachpb::_TxnAlreadyEncounteredErrorError_default_instance_);
}
inline ::cockroach::roachpb::TxnAlreadyEncounteredErrorError* ErrorDetail::mutable_txn_already_encountered_error() {
  if (!has_txn_already_encountered_error()) {
    clear_value();
    set_has_txn_already_encountered_error();
    value_.txn_already_encountered_error_ = CreateMaybeMessage< ::cockroach::roachpb::TxnAlreadyEncounteredErrorError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.txn_already_encountered_error)
  return value_.txn_already_encountered_error_;
}

// optional .cockroach.roachpb.IntentMissingError intent_missing = 36;
inline bool ErrorDetail::has_intent_missing() const {
  return value_case() == kIntentMissing;
}
inline void ErrorDetail::set_has_intent_missing() {
  _oneof_case_[0] = kIntentMissing;
}
inline void ErrorDetail::clear_intent_missing() {
  if (has_intent_missing()) {
    delete value_.intent_missing_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::IntentMissingError& ErrorDetail::_internal_intent_missing() const {
  return *value_.intent_missing_;
}
inline ::cockroach::roachpb::IntentMissingError* ErrorDetail::release_intent_missing() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.intent_missing)
  if (has_intent_missing()) {
    clear_has_value();
      ::cockroach::roachpb::IntentMissingError* temp = value_.intent_missing_;
    value_.intent_missing_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::IntentMissingError& ErrorDetail::intent_missing() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.intent_missing)
  return has_intent_missing()
      ? *value_.intent_missing_
      : *reinterpret_cast< ::cockroach::roachpb::IntentMissingError*>(&::cockroach::roachpb::_IntentMissingError_default_instance_);
}
inline ::cockroach::roachpb::IntentMissingError* ErrorDetail::mutable_intent_missing() {
  if (!has_intent_missing()) {
    clear_value();
    set_has_intent_missing();
    value_.intent_missing_ = CreateMaybeMessage< ::cockroach::roachpb::IntentMissingError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.intent_missing)
  return value_.intent_missing_;
}

// optional .cockroach.roachpb.MergeInProgressError merge_in_progress = 37;
inline bool ErrorDetail::has_merge_in_progress() const {
  return value_case() == kMergeInProgress;
}
inline void ErrorDetail::set_has_merge_in_progress() {
  _oneof_case_[0] = kMergeInProgress;
}
inline void ErrorDetail::clear_merge_in_progress() {
  if (has_merge_in_progress()) {
    delete value_.merge_in_progress_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::MergeInProgressError& ErrorDetail::_internal_merge_in_progress() const {
  return *value_.merge_in_progress_;
}
inline ::cockroach::roachpb::MergeInProgressError* ErrorDetail::release_merge_in_progress() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.merge_in_progress)
  if (has_merge_in_progress()) {
    clear_has_value();
      ::cockroach::roachpb::MergeInProgressError* temp = value_.merge_in_progress_;
    value_.merge_in_progress_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::MergeInProgressError& ErrorDetail::merge_in_progress() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.merge_in_progress)
  return has_merge_in_progress()
      ? *value_.merge_in_progress_
      : *reinterpret_cast< ::cockroach::roachpb::MergeInProgressError*>(&::cockroach::roachpb::_MergeInProgressError_default_instance_);
}
inline ::cockroach::roachpb::MergeInProgressError* ErrorDetail::mutable_merge_in_progress() {
  if (!has_merge_in_progress()) {
    clear_value();
    set_has_merge_in_progress();
    value_.merge_in_progress_ = CreateMaybeMessage< ::cockroach::roachpb::MergeInProgressError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.merge_in_progress)
  return value_.merge_in_progress_;
}

// optional .cockroach.roachpb.RangeFeedRetryError rangefeed_retry = 38;
inline bool ErrorDetail::has_rangefeed_retry() const {
  return value_case() == kRangefeedRetry;
}
inline void ErrorDetail::set_has_rangefeed_retry() {
  _oneof_case_[0] = kRangefeedRetry;
}
inline void ErrorDetail::clear_rangefeed_retry() {
  if (has_rangefeed_retry()) {
    delete value_.rangefeed_retry_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::RangeFeedRetryError& ErrorDetail::_internal_rangefeed_retry() const {
  return *value_.rangefeed_retry_;
}
inline ::cockroach::roachpb::RangeFeedRetryError* ErrorDetail::release_rangefeed_retry() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.rangefeed_retry)
  if (has_rangefeed_retry()) {
    clear_has_value();
      ::cockroach::roachpb::RangeFeedRetryError* temp = value_.rangefeed_retry_;
    value_.rangefeed_retry_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::RangeFeedRetryError& ErrorDetail::rangefeed_retry() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.rangefeed_retry)
  return has_rangefeed_retry()
      ? *value_.rangefeed_retry_
      : *reinterpret_cast< ::cockroach::roachpb::RangeFeedRetryError*>(&::cockroach::roachpb::_RangeFeedRetryError_default_instance_);
}
inline ::cockroach::roachpb::RangeFeedRetryError* ErrorDetail::mutable_rangefeed_retry() {
  if (!has_rangefeed_retry()) {
    clear_value();
    set_has_rangefeed_retry();
    value_.rangefeed_retry_ = CreateMaybeMessage< ::cockroach::roachpb::RangeFeedRetryError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.rangefeed_retry)
  return value_.rangefeed_retry_;
}

// optional .cockroach.roachpb.IndeterminateCommitError indeterminate_commit = 39;
inline bool ErrorDetail::has_indeterminate_commit() const {
  return value_case() == kIndeterminateCommit;
}
inline void ErrorDetail::set_has_indeterminate_commit() {
  _oneof_case_[0] = kIndeterminateCommit;
}
inline void ErrorDetail::clear_indeterminate_commit() {
  if (has_indeterminate_commit()) {
    delete value_.indeterminate_commit_;
    clear_has_value();
  }
}
inline const ::cockroach::roachpb::IndeterminateCommitError& ErrorDetail::_internal_indeterminate_commit() const {
  return *value_.indeterminate_commit_;
}
inline ::cockroach::roachpb::IndeterminateCommitError* ErrorDetail::release_indeterminate_commit() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.ErrorDetail.indeterminate_commit)
  if (has_indeterminate_commit()) {
    clear_has_value();
      ::cockroach::roachpb::IndeterminateCommitError* temp = value_.indeterminate_commit_;
    value_.indeterminate_commit_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline const ::cockroach::roachpb::IndeterminateCommitError& ErrorDetail::indeterminate_commit() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrorDetail.indeterminate_commit)
  return has_indeterminate_commit()
      ? *value_.indeterminate_commit_
      : *reinterpret_cast< ::cockroach::roachpb::IndeterminateCommitError*>(&::cockroach::roachpb::_IndeterminateCommitError_default_instance_);
}
inline ::cockroach::roachpb::IndeterminateCommitError* ErrorDetail::mutable_indeterminate_commit() {
  if (!has_indeterminate_commit()) {
    clear_value();
    set_has_indeterminate_commit();
    value_.indeterminate_commit_ = CreateMaybeMessage< ::cockroach::roachpb::IndeterminateCommitError >(
        GetArenaNoVirtual());
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.ErrorDetail.indeterminate_commit)
  return value_.indeterminate_commit_;
}

inline bool ErrorDetail::has_value() const {
  return value_case() != VALUE_NOT_SET;
}
inline void ErrorDetail::clear_has_value() {
  _oneof_case_[0] = VALUE_NOT_SET;
}
inline ErrorDetail::ValueCase ErrorDetail::value_case() const {
  return ErrorDetail::ValueCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// ErrPosition

inline bool ErrPosition::has_index() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ErrPosition::set_has_index() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ErrPosition::clear_has_index() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ErrPosition::clear_index() {
  index_ = 0;
  clear_has_index();
}
inline ::google::protobuf::int32 ErrPosition::index() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.ErrPosition.index)
  return index_;
}
inline void ErrPosition::set_index(::google::protobuf::int32 value) {
  set_has_index();
  index_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.ErrPosition.index)
}

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

// Error

inline bool Error::has_message() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void Error::set_has_message() {
  _has_bits_[0] |= 0x00000001u;
}
inline void Error::clear_has_message() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void Error::clear_message() {
  message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_message();
}
inline const ::std::string& Error::message() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Error.message)
  return message_.GetNoArena();
}
inline void Error::set_message(const ::std::string& value) {
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Error.message)
}
#if LANG_CXX11
inline void Error::set_message(::std::string&& value) {
  set_has_message();
  message_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:cockroach.roachpb.Error.message)
}
#endif
inline void Error::set_message(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:cockroach.roachpb.Error.message)
}
inline void Error::set_message(const char* value, size_t size) {
  set_has_message();
  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:cockroach.roachpb.Error.message)
}
inline ::std::string* Error::mutable_message() {
  set_has_message();
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.Error.message)
  return message_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* Error::release_message() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.Error.message)
  if (!has_message()) {
    return NULL;
  }
  clear_has_message();
  return message_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void Error::set_allocated_message(::std::string* message) {
  if (message != NULL) {
    set_has_message();
  } else {
    clear_has_message();
  }
  message_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), message);
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.Error.message)
}

inline bool Error::has_transaction_restart() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void Error::set_has_transaction_restart() {
  _has_bits_[0] |= 0x00000020u;
}
inline void Error::clear_has_transaction_restart() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void Error::clear_transaction_restart() {
  transaction_restart_ = 0;
  clear_has_transaction_restart();
}
inline ::cockroach::roachpb::TransactionRestart Error::transaction_restart() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Error.transaction_restart)
  return static_cast< ::cockroach::roachpb::TransactionRestart >(transaction_restart_);
}
inline void Error::set_transaction_restart(::cockroach::roachpb::TransactionRestart value) {
  assert(::cockroach::roachpb::TransactionRestart_IsValid(value));
  set_has_transaction_restart();
  transaction_restart_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Error.transaction_restart)
}

// optional .cockroach.roachpb.Transaction unexposed_txn = 4;
inline bool Error::has_unexposed_txn() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void Error::set_has_unexposed_txn() {
  _has_bits_[0] |= 0x00000002u;
}
inline void Error::clear_has_unexposed_txn() {
  _has_bits_[0] &= ~0x00000002u;
}
inline const ::cockroach::roachpb::Transaction& Error::_internal_unexposed_txn() const {
  return *unexposed_txn_;
}
inline const ::cockroach::roachpb::Transaction& Error::unexposed_txn() const {
  const ::cockroach::roachpb::Transaction* p = unexposed_txn_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Error.unexposed_txn)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::Transaction*>(
      &::cockroach::roachpb::_Transaction_default_instance_);
}
inline ::cockroach::roachpb::Transaction* Error::release_unexposed_txn() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.Error.unexposed_txn)
  clear_has_unexposed_txn();
  ::cockroach::roachpb::Transaction* temp = unexposed_txn_;
  unexposed_txn_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::Transaction* Error::mutable_unexposed_txn() {
  set_has_unexposed_txn();
  if (unexposed_txn_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::Transaction>(GetArenaNoVirtual());
    unexposed_txn_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.Error.unexposed_txn)
  return unexposed_txn_;
}
inline void Error::set_allocated_unexposed_txn(::cockroach::roachpb::Transaction* unexposed_txn) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(unexposed_txn_);
  }
  if (unexposed_txn) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      unexposed_txn = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, unexposed_txn, submessage_arena);
    }
    set_has_unexposed_txn();
  } else {
    clear_has_unexposed_txn();
  }
  unexposed_txn_ = unexposed_txn;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.Error.unexposed_txn)
}

inline bool Error::has_origin_node() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void Error::set_has_origin_node() {
  _has_bits_[0] |= 0x00000040u;
}
inline void Error::clear_has_origin_node() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void Error::clear_origin_node() {
  origin_node_ = 0;
  clear_has_origin_node();
}
inline ::google::protobuf::int32 Error::origin_node() const {
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Error.origin_node)
  return origin_node_;
}
inline void Error::set_origin_node(::google::protobuf::int32 value) {
  set_has_origin_node();
  origin_node_ = value;
  // @@protoc_insertion_point(field_set:cockroach.roachpb.Error.origin_node)
}

inline bool Error::has_detail() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void Error::set_has_detail() {
  _has_bits_[0] |= 0x00000004u;
}
inline void Error::clear_has_detail() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void Error::clear_detail() {
  if (detail_ != NULL) detail_->Clear();
  clear_has_detail();
}
inline const ::cockroach::roachpb::ErrorDetail& Error::_internal_detail() const {
  return *detail_;
}
inline const ::cockroach::roachpb::ErrorDetail& Error::detail() const {
  const ::cockroach::roachpb::ErrorDetail* p = detail_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Error.detail)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::ErrorDetail*>(
      &::cockroach::roachpb::_ErrorDetail_default_instance_);
}
inline ::cockroach::roachpb::ErrorDetail* Error::release_detail() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.Error.detail)
  clear_has_detail();
  ::cockroach::roachpb::ErrorDetail* temp = detail_;
  detail_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::ErrorDetail* Error::mutable_detail() {
  set_has_detail();
  if (detail_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::ErrorDetail>(GetArenaNoVirtual());
    detail_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.Error.detail)
  return detail_;
}
inline void Error::set_allocated_detail(::cockroach::roachpb::ErrorDetail* detail) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete detail_;
  }
  if (detail) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      detail = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, detail, submessage_arena);
    }
    set_has_detail();
  } else {
    clear_has_detail();
  }
  detail_ = detail;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.Error.detail)
}

// optional .cockroach.roachpb.ErrPosition index = 7;
inline bool Error::has_index() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void Error::set_has_index() {
  _has_bits_[0] |= 0x00000008u;
}
inline void Error::clear_has_index() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void Error::clear_index() {
  if (index_ != NULL) index_->Clear();
  clear_has_index();
}
inline const ::cockroach::roachpb::ErrPosition& Error::_internal_index() const {
  return *index_;
}
inline const ::cockroach::roachpb::ErrPosition& Error::index() const {
  const ::cockroach::roachpb::ErrPosition* p = index_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Error.index)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::roachpb::ErrPosition*>(
      &::cockroach::roachpb::_ErrPosition_default_instance_);
}
inline ::cockroach::roachpb::ErrPosition* Error::release_index() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.Error.index)
  clear_has_index();
  ::cockroach::roachpb::ErrPosition* temp = index_;
  index_ = NULL;
  return temp;
}
inline ::cockroach::roachpb::ErrPosition* Error::mutable_index() {
  set_has_index();
  if (index_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::roachpb::ErrPosition>(GetArenaNoVirtual());
    index_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.Error.index)
  return index_;
}
inline void Error::set_allocated_index(::cockroach::roachpb::ErrPosition* index) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete index_;
  }
  if (index) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      index = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, index, submessage_arena);
    }
    set_has_index();
  } else {
    clear_has_index();
  }
  index_ = index;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.Error.index)
}

inline bool Error::has_now() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void Error::set_has_now() {
  _has_bits_[0] |= 0x00000010u;
}
inline void Error::clear_has_now() {
  _has_bits_[0] &= ~0x00000010u;
}
inline const ::cockroach::util::hlc::Timestamp& Error::_internal_now() const {
  return *now_;
}
inline const ::cockroach::util::hlc::Timestamp& Error::now() const {
  const ::cockroach::util::hlc::Timestamp* p = now_;
  // @@protoc_insertion_point(field_get:cockroach.roachpb.Error.now)
  return p != NULL ? *p : *reinterpret_cast<const ::cockroach::util::hlc::Timestamp*>(
      &::cockroach::util::hlc::_Timestamp_default_instance_);
}
inline ::cockroach::util::hlc::Timestamp* Error::release_now() {
  // @@protoc_insertion_point(field_release:cockroach.roachpb.Error.now)
  clear_has_now();
  ::cockroach::util::hlc::Timestamp* temp = now_;
  now_ = NULL;
  return temp;
}
inline ::cockroach::util::hlc::Timestamp* Error::mutable_now() {
  set_has_now();
  if (now_ == NULL) {
    auto* p = CreateMaybeMessage<::cockroach::util::hlc::Timestamp>(GetArenaNoVirtual());
    now_ = p;
  }
  // @@protoc_insertion_point(field_mutable:cockroach.roachpb.Error.now)
  return now_;
}
inline void Error::set_allocated_now(::cockroach::util::hlc::Timestamp* now) {
  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == NULL) {
    delete reinterpret_cast< ::google::protobuf::MessageLite*>(now_);
  }
  if (now) {
    ::google::protobuf::Arena* submessage_arena = NULL;
    if (message_arena != submessage_arena) {
      now = ::google::protobuf::internal::GetOwnedMessage(
          message_arena, now, submessage_arena);
    }
    set_has_now();
  } else {
    clear_has_now();
  }
  now_ = now;
  // @@protoc_insertion_point(field_set_allocated:cockroach.roachpb.Error.now)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace roachpb
}  // namespace cockroach

namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::cockroach::roachpb::TransactionStatusError_Reason> : ::std::true_type {};
template <> struct is_proto_enum< ::cockroach::roachpb::RangeFeedRetryError_Reason> : ::std::true_type {};
template <> struct is_proto_enum< ::cockroach::roachpb::TransactionAbortedReason> : ::std::true_type {};
template <> struct is_proto_enum< ::cockroach::roachpb::TransactionRetryReason> : ::std::true_type {};
template <> struct is_proto_enum< ::cockroach::roachpb::TransactionRestart> : ::std::true_type {};

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_INCLUDED_roachpb_2ferrors_2eproto