// DO NOT EDIT.
// swift-format-ignore-file
//
// Generated by the Swift generator plugin for the protocol buffer compiler.
// Source: tendermint/abci/types.proto
//
// For information on using the generated types, please see the documentation:
//   https://github.com/apple/swift-protobuf/

import Foundation
import SwiftProtobuf

// If the compiler emits an error on this type, it is because this file
// was generated by a version of the `protoc` Swift plug-in that is
// incompatible with the version of SwiftProtobuf to which you are linking.
// Please ensure that you are building against the same version of the API
// that was used to generate this file.
fileprivate struct _GeneratedWithProtocGenSwiftVersion: SwiftProtobuf.ProtobufAPIVersionCheck {
  struct _2: SwiftProtobuf.ProtobufAPIVersion_2 {}
  typealias Version = _2
}

enum Tendermint_Abci_CheckTxType: SwiftProtobuf.Enum {
  typealias RawValue = Int
  case new // = 0
  case recheck // = 1
  case UNRECOGNIZED(Int)

  init() {
    self = .new
  }

  init?(rawValue: Int) {
    switch rawValue {
    case 0: self = .new
    case 1: self = .recheck
    default: self = .UNRECOGNIZED(rawValue)
    }
  }

  var rawValue: Int {
    switch self {
    case .new: return 0
    case .recheck: return 1
    case .UNRECOGNIZED(let i): return i
    }
  }

}

#if swift(>=4.2)

extension Tendermint_Abci_CheckTxType: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [Tendermint_Abci_CheckTxType] = [
    .new,
    .recheck,
  ]
}

#endif  // swift(>=4.2)

enum Tendermint_Abci_EvidenceType: SwiftProtobuf.Enum {
  typealias RawValue = Int
  case unknown // = 0
  case duplicateVote // = 1
  case lightClientAttack // = 2
  case UNRECOGNIZED(Int)

  init() {
    self = .unknown
  }

  init?(rawValue: Int) {
    switch rawValue {
    case 0: self = .unknown
    case 1: self = .duplicateVote
    case 2: self = .lightClientAttack
    default: self = .UNRECOGNIZED(rawValue)
    }
  }

  var rawValue: Int {
    switch self {
    case .unknown: return 0
    case .duplicateVote: return 1
    case .lightClientAttack: return 2
    case .UNRECOGNIZED(let i): return i
    }
  }

}

#if swift(>=4.2)

extension Tendermint_Abci_EvidenceType: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [Tendermint_Abci_EvidenceType] = [
    .unknown,
    .duplicateVote,
    .lightClientAttack,
  ]
}

#endif  // swift(>=4.2)

struct Tendermint_Abci_Request {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var value: Tendermint_Abci_Request.OneOf_Value? = nil

  var echo: Tendermint_Abci_RequestEcho {
    get {
      if case .echo(let v)? = value {return v}
      return Tendermint_Abci_RequestEcho()
    }
    set {value = .echo(newValue)}
  }

  var flush: Tendermint_Abci_RequestFlush {
    get {
      if case .flush(let v)? = value {return v}
      return Tendermint_Abci_RequestFlush()
    }
    set {value = .flush(newValue)}
  }

  var info: Tendermint_Abci_RequestInfo {
    get {
      if case .info(let v)? = value {return v}
      return Tendermint_Abci_RequestInfo()
    }
    set {value = .info(newValue)}
  }

  var setOption: Tendermint_Abci_RequestSetOption {
    get {
      if case .setOption(let v)? = value {return v}
      return Tendermint_Abci_RequestSetOption()
    }
    set {value = .setOption(newValue)}
  }

  var initChain: Tendermint_Abci_RequestInitChain {
    get {
      if case .initChain(let v)? = value {return v}
      return Tendermint_Abci_RequestInitChain()
    }
    set {value = .initChain(newValue)}
  }

  var query: Tendermint_Abci_RequestQuery {
    get {
      if case .query(let v)? = value {return v}
      return Tendermint_Abci_RequestQuery()
    }
    set {value = .query(newValue)}
  }

  var beginBlock: Tendermint_Abci_RequestBeginBlock {
    get {
      if case .beginBlock(let v)? = value {return v}
      return Tendermint_Abci_RequestBeginBlock()
    }
    set {value = .beginBlock(newValue)}
  }

  var checkTx: Tendermint_Abci_RequestCheckTx {
    get {
      if case .checkTx(let v)? = value {return v}
      return Tendermint_Abci_RequestCheckTx()
    }
    set {value = .checkTx(newValue)}
  }

  var deliverTx: Tendermint_Abci_RequestDeliverTx {
    get {
      if case .deliverTx(let v)? = value {return v}
      return Tendermint_Abci_RequestDeliverTx()
    }
    set {value = .deliverTx(newValue)}
  }

  var endBlock: Tendermint_Abci_RequestEndBlock {
    get {
      if case .endBlock(let v)? = value {return v}
      return Tendermint_Abci_RequestEndBlock()
    }
    set {value = .endBlock(newValue)}
  }

  var commit: Tendermint_Abci_RequestCommit {
    get {
      if case .commit(let v)? = value {return v}
      return Tendermint_Abci_RequestCommit()
    }
    set {value = .commit(newValue)}
  }

  var listSnapshots: Tendermint_Abci_RequestListSnapshots {
    get {
      if case .listSnapshots(let v)? = value {return v}
      return Tendermint_Abci_RequestListSnapshots()
    }
    set {value = .listSnapshots(newValue)}
  }

  var offerSnapshot: Tendermint_Abci_RequestOfferSnapshot {
    get {
      if case .offerSnapshot(let v)? = value {return v}
      return Tendermint_Abci_RequestOfferSnapshot()
    }
    set {value = .offerSnapshot(newValue)}
  }

  var loadSnapshotChunk: Tendermint_Abci_RequestLoadSnapshotChunk {
    get {
      if case .loadSnapshotChunk(let v)? = value {return v}
      return Tendermint_Abci_RequestLoadSnapshotChunk()
    }
    set {value = .loadSnapshotChunk(newValue)}
  }

  var applySnapshotChunk: Tendermint_Abci_RequestApplySnapshotChunk {
    get {
      if case .applySnapshotChunk(let v)? = value {return v}
      return Tendermint_Abci_RequestApplySnapshotChunk()
    }
    set {value = .applySnapshotChunk(newValue)}
  }

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum OneOf_Value: Equatable {
    case echo(Tendermint_Abci_RequestEcho)
    case flush(Tendermint_Abci_RequestFlush)
    case info(Tendermint_Abci_RequestInfo)
    case setOption(Tendermint_Abci_RequestSetOption)
    case initChain(Tendermint_Abci_RequestInitChain)
    case query(Tendermint_Abci_RequestQuery)
    case beginBlock(Tendermint_Abci_RequestBeginBlock)
    case checkTx(Tendermint_Abci_RequestCheckTx)
    case deliverTx(Tendermint_Abci_RequestDeliverTx)
    case endBlock(Tendermint_Abci_RequestEndBlock)
    case commit(Tendermint_Abci_RequestCommit)
    case listSnapshots(Tendermint_Abci_RequestListSnapshots)
    case offerSnapshot(Tendermint_Abci_RequestOfferSnapshot)
    case loadSnapshotChunk(Tendermint_Abci_RequestLoadSnapshotChunk)
    case applySnapshotChunk(Tendermint_Abci_RequestApplySnapshotChunk)

  #if !swift(>=4.1)
    static func ==(lhs: Tendermint_Abci_Request.OneOf_Value, rhs: Tendermint_Abci_Request.OneOf_Value) -> Bool {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch (lhs, rhs) {
      case (.echo, .echo): return {
        guard case .echo(let l) = lhs, case .echo(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.flush, .flush): return {
        guard case .flush(let l) = lhs, case .flush(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.info, .info): return {
        guard case .info(let l) = lhs, case .info(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.setOption, .setOption): return {
        guard case .setOption(let l) = lhs, case .setOption(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.initChain, .initChain): return {
        guard case .initChain(let l) = lhs, case .initChain(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.query, .query): return {
        guard case .query(let l) = lhs, case .query(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.beginBlock, .beginBlock): return {
        guard case .beginBlock(let l) = lhs, case .beginBlock(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.checkTx, .checkTx): return {
        guard case .checkTx(let l) = lhs, case .checkTx(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.deliverTx, .deliverTx): return {
        guard case .deliverTx(let l) = lhs, case .deliverTx(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.endBlock, .endBlock): return {
        guard case .endBlock(let l) = lhs, case .endBlock(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.commit, .commit): return {
        guard case .commit(let l) = lhs, case .commit(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.listSnapshots, .listSnapshots): return {
        guard case .listSnapshots(let l) = lhs, case .listSnapshots(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.offerSnapshot, .offerSnapshot): return {
        guard case .offerSnapshot(let l) = lhs, case .offerSnapshot(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.loadSnapshotChunk, .loadSnapshotChunk): return {
        guard case .loadSnapshotChunk(let l) = lhs, case .loadSnapshotChunk(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.applySnapshotChunk, .applySnapshotChunk): return {
        guard case .applySnapshotChunk(let l) = lhs, case .applySnapshotChunk(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      default: return false
      }
    }
  #endif
  }

  init() {}
}

struct Tendermint_Abci_RequestEcho {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var message: String = String()

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_RequestFlush {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_RequestInfo {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var version: String = String()

  var blockVersion: UInt64 = 0

  var p2PVersion: UInt64 = 0

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

/// nondeterministic
struct Tendermint_Abci_RequestSetOption {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var key: String = String()

  var value: String = String()

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_RequestInitChain {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var time: SwiftProtobuf.Google_Protobuf_Timestamp {
    get {return _time ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
    set {_time = newValue}
  }
  /// Returns true if `time` has been explicitly set.
  var hasTime: Bool {return self._time != nil}
  /// Clears the value of `time`. Subsequent reads from it will return its default value.
  mutating func clearTime() {self._time = nil}

  var chainID: String = String()

  var consensusParams: Tendermint_Abci_ConsensusParams {
    get {return _consensusParams ?? Tendermint_Abci_ConsensusParams()}
    set {_consensusParams = newValue}
  }
  /// Returns true if `consensusParams` has been explicitly set.
  var hasConsensusParams: Bool {return self._consensusParams != nil}
  /// Clears the value of `consensusParams`. Subsequent reads from it will return its default value.
  mutating func clearConsensusParams() {self._consensusParams = nil}

  var validators: [Tendermint_Abci_ValidatorUpdate] = []

  var appStateBytes: Data = Data()

  var initialHeight: Int64 = 0

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _time: SwiftProtobuf.Google_Protobuf_Timestamp? = nil
  fileprivate var _consensusParams: Tendermint_Abci_ConsensusParams? = nil
}

struct Tendermint_Abci_RequestQuery {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var data: Data = Data()

  var path: String = String()

  var height: Int64 = 0

  var prove: Bool = false

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_RequestBeginBlock {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var hash: Data = Data()

  var header: Tendermint_Types_Header {
    get {return _header ?? Tendermint_Types_Header()}
    set {_header = newValue}
  }
  /// Returns true if `header` has been explicitly set.
  var hasHeader: Bool {return self._header != nil}
  /// Clears the value of `header`. Subsequent reads from it will return its default value.
  mutating func clearHeader() {self._header = nil}

  var lastCommitInfo: Tendermint_Abci_LastCommitInfo {
    get {return _lastCommitInfo ?? Tendermint_Abci_LastCommitInfo()}
    set {_lastCommitInfo = newValue}
  }
  /// Returns true if `lastCommitInfo` has been explicitly set.
  var hasLastCommitInfo: Bool {return self._lastCommitInfo != nil}
  /// Clears the value of `lastCommitInfo`. Subsequent reads from it will return its default value.
  mutating func clearLastCommitInfo() {self._lastCommitInfo = nil}

  var byzantineValidators: [Tendermint_Abci_Evidence] = []

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _header: Tendermint_Types_Header? = nil
  fileprivate var _lastCommitInfo: Tendermint_Abci_LastCommitInfo? = nil
}

struct Tendermint_Abci_RequestCheckTx {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var tx: Data = Data()

  var type: Tendermint_Abci_CheckTxType = .new

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_RequestDeliverTx {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var tx: Data = Data()

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_RequestEndBlock {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var height: Int64 = 0

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_RequestCommit {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

/// lists available snapshots
struct Tendermint_Abci_RequestListSnapshots {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

/// offers a snapshot to the application
struct Tendermint_Abci_RequestOfferSnapshot {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  /// snapshot offered by peers
  var snapshot: Tendermint_Abci_Snapshot {
    get {return _snapshot ?? Tendermint_Abci_Snapshot()}
    set {_snapshot = newValue}
  }
  /// Returns true if `snapshot` has been explicitly set.
  var hasSnapshot: Bool {return self._snapshot != nil}
  /// Clears the value of `snapshot`. Subsequent reads from it will return its default value.
  mutating func clearSnapshot() {self._snapshot = nil}

  /// light client-verified app hash for snapshot height
  var appHash: Data = Data()

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _snapshot: Tendermint_Abci_Snapshot? = nil
}

/// loads a snapshot chunk
struct Tendermint_Abci_RequestLoadSnapshotChunk {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var height: UInt64 = 0

  var format: UInt32 = 0

  var chunk: UInt32 = 0

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

/// Applies a snapshot chunk
struct Tendermint_Abci_RequestApplySnapshotChunk {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var index: UInt32 = 0

  var chunk: Data = Data()

  var sender: String = String()

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_Response {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var value: Tendermint_Abci_Response.OneOf_Value? = nil

  var exception: Tendermint_Abci_ResponseException {
    get {
      if case .exception(let v)? = value {return v}
      return Tendermint_Abci_ResponseException()
    }
    set {value = .exception(newValue)}
  }

  var echo: Tendermint_Abci_ResponseEcho {
    get {
      if case .echo(let v)? = value {return v}
      return Tendermint_Abci_ResponseEcho()
    }
    set {value = .echo(newValue)}
  }

  var flush: Tendermint_Abci_ResponseFlush {
    get {
      if case .flush(let v)? = value {return v}
      return Tendermint_Abci_ResponseFlush()
    }
    set {value = .flush(newValue)}
  }

  var info: Tendermint_Abci_ResponseInfo {
    get {
      if case .info(let v)? = value {return v}
      return Tendermint_Abci_ResponseInfo()
    }
    set {value = .info(newValue)}
  }

  var setOption: Tendermint_Abci_ResponseSetOption {
    get {
      if case .setOption(let v)? = value {return v}
      return Tendermint_Abci_ResponseSetOption()
    }
    set {value = .setOption(newValue)}
  }

  var initChain: Tendermint_Abci_ResponseInitChain {
    get {
      if case .initChain(let v)? = value {return v}
      return Tendermint_Abci_ResponseInitChain()
    }
    set {value = .initChain(newValue)}
  }

  var query: Tendermint_Abci_ResponseQuery {
    get {
      if case .query(let v)? = value {return v}
      return Tendermint_Abci_ResponseQuery()
    }
    set {value = .query(newValue)}
  }

  var beginBlock: Tendermint_Abci_ResponseBeginBlock {
    get {
      if case .beginBlock(let v)? = value {return v}
      return Tendermint_Abci_ResponseBeginBlock()
    }
    set {value = .beginBlock(newValue)}
  }

  var checkTx: Tendermint_Abci_ResponseCheckTx {
    get {
      if case .checkTx(let v)? = value {return v}
      return Tendermint_Abci_ResponseCheckTx()
    }
    set {value = .checkTx(newValue)}
  }

  var deliverTx: Tendermint_Abci_ResponseDeliverTx {
    get {
      if case .deliverTx(let v)? = value {return v}
      return Tendermint_Abci_ResponseDeliverTx()
    }
    set {value = .deliverTx(newValue)}
  }

  var endBlock: Tendermint_Abci_ResponseEndBlock {
    get {
      if case .endBlock(let v)? = value {return v}
      return Tendermint_Abci_ResponseEndBlock()
    }
    set {value = .endBlock(newValue)}
  }

  var commit: Tendermint_Abci_ResponseCommit {
    get {
      if case .commit(let v)? = value {return v}
      return Tendermint_Abci_ResponseCommit()
    }
    set {value = .commit(newValue)}
  }

  var listSnapshots: Tendermint_Abci_ResponseListSnapshots {
    get {
      if case .listSnapshots(let v)? = value {return v}
      return Tendermint_Abci_ResponseListSnapshots()
    }
    set {value = .listSnapshots(newValue)}
  }

  var offerSnapshot: Tendermint_Abci_ResponseOfferSnapshot {
    get {
      if case .offerSnapshot(let v)? = value {return v}
      return Tendermint_Abci_ResponseOfferSnapshot()
    }
    set {value = .offerSnapshot(newValue)}
  }

  var loadSnapshotChunk: Tendermint_Abci_ResponseLoadSnapshotChunk {
    get {
      if case .loadSnapshotChunk(let v)? = value {return v}
      return Tendermint_Abci_ResponseLoadSnapshotChunk()
    }
    set {value = .loadSnapshotChunk(newValue)}
  }

  var applySnapshotChunk: Tendermint_Abci_ResponseApplySnapshotChunk {
    get {
      if case .applySnapshotChunk(let v)? = value {return v}
      return Tendermint_Abci_ResponseApplySnapshotChunk()
    }
    set {value = .applySnapshotChunk(newValue)}
  }

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum OneOf_Value: Equatable {
    case exception(Tendermint_Abci_ResponseException)
    case echo(Tendermint_Abci_ResponseEcho)
    case flush(Tendermint_Abci_ResponseFlush)
    case info(Tendermint_Abci_ResponseInfo)
    case setOption(Tendermint_Abci_ResponseSetOption)
    case initChain(Tendermint_Abci_ResponseInitChain)
    case query(Tendermint_Abci_ResponseQuery)
    case beginBlock(Tendermint_Abci_ResponseBeginBlock)
    case checkTx(Tendermint_Abci_ResponseCheckTx)
    case deliverTx(Tendermint_Abci_ResponseDeliverTx)
    case endBlock(Tendermint_Abci_ResponseEndBlock)
    case commit(Tendermint_Abci_ResponseCommit)
    case listSnapshots(Tendermint_Abci_ResponseListSnapshots)
    case offerSnapshot(Tendermint_Abci_ResponseOfferSnapshot)
    case loadSnapshotChunk(Tendermint_Abci_ResponseLoadSnapshotChunk)
    case applySnapshotChunk(Tendermint_Abci_ResponseApplySnapshotChunk)

  #if !swift(>=4.1)
    static func ==(lhs: Tendermint_Abci_Response.OneOf_Value, rhs: Tendermint_Abci_Response.OneOf_Value) -> Bool {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch (lhs, rhs) {
      case (.exception, .exception): return {
        guard case .exception(let l) = lhs, case .exception(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.echo, .echo): return {
        guard case .echo(let l) = lhs, case .echo(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.flush, .flush): return {
        guard case .flush(let l) = lhs, case .flush(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.info, .info): return {
        guard case .info(let l) = lhs, case .info(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.setOption, .setOption): return {
        guard case .setOption(let l) = lhs, case .setOption(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.initChain, .initChain): return {
        guard case .initChain(let l) = lhs, case .initChain(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.query, .query): return {
        guard case .query(let l) = lhs, case .query(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.beginBlock, .beginBlock): return {
        guard case .beginBlock(let l) = lhs, case .beginBlock(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.checkTx, .checkTx): return {
        guard case .checkTx(let l) = lhs, case .checkTx(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.deliverTx, .deliverTx): return {
        guard case .deliverTx(let l) = lhs, case .deliverTx(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.endBlock, .endBlock): return {
        guard case .endBlock(let l) = lhs, case .endBlock(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.commit, .commit): return {
        guard case .commit(let l) = lhs, case .commit(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.listSnapshots, .listSnapshots): return {
        guard case .listSnapshots(let l) = lhs, case .listSnapshots(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.offerSnapshot, .offerSnapshot): return {
        guard case .offerSnapshot(let l) = lhs, case .offerSnapshot(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.loadSnapshotChunk, .loadSnapshotChunk): return {
        guard case .loadSnapshotChunk(let l) = lhs, case .loadSnapshotChunk(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      case (.applySnapshotChunk, .applySnapshotChunk): return {
        guard case .applySnapshotChunk(let l) = lhs, case .applySnapshotChunk(let r) = rhs else { preconditionFailure() }
        return l == r
      }()
      default: return false
      }
    }
  #endif
  }

  init() {}
}

/// nondeterministic
struct Tendermint_Abci_ResponseException {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var error: String = String()

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_ResponseEcho {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var message: String = String()

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_ResponseFlush {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_ResponseInfo {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var data: String = String()

  var version: String = String()

  var appVersion: UInt64 = 0

  var lastBlockHeight: Int64 = 0

  var lastBlockAppHash: Data = Data()

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

/// nondeterministic
struct Tendermint_Abci_ResponseSetOption {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var code: UInt32 = 0

  /// bytes data = 2;
  var log: String = String()

  var info: String = String()

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_ResponseInitChain {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var consensusParams: Tendermint_Abci_ConsensusParams {
    get {return _consensusParams ?? Tendermint_Abci_ConsensusParams()}
    set {_consensusParams = newValue}
  }
  /// Returns true if `consensusParams` has been explicitly set.
  var hasConsensusParams: Bool {return self._consensusParams != nil}
  /// Clears the value of `consensusParams`. Subsequent reads from it will return its default value.
  mutating func clearConsensusParams() {self._consensusParams = nil}

  var validators: [Tendermint_Abci_ValidatorUpdate] = []

  var appHash: Data = Data()

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _consensusParams: Tendermint_Abci_ConsensusParams? = nil
}

struct Tendermint_Abci_ResponseQuery {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var code: UInt32 = 0

  /// bytes data = 2; // use "value" instead.
  var log: String = String()

  /// nondeterministic
  var info: String = String()

  var index: Int64 = 0

  var key: Data = Data()

  var value: Data = Data()

  var proofOps: Tendermint_Crypto_ProofOps {
    get {return _proofOps ?? Tendermint_Crypto_ProofOps()}
    set {_proofOps = newValue}
  }
  /// Returns true if `proofOps` has been explicitly set.
  var hasProofOps: Bool {return self._proofOps != nil}
  /// Clears the value of `proofOps`. Subsequent reads from it will return its default value.
  mutating func clearProofOps() {self._proofOps = nil}

  var height: Int64 = 0

  var codespace: String = String()

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _proofOps: Tendermint_Crypto_ProofOps? = nil
}

struct Tendermint_Abci_ResponseBeginBlock {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var events: [Tendermint_Abci_Event] = []

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_ResponseCheckTx {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var code: UInt32 = 0

  var data: Data = Data()

  /// nondeterministic
  var log: String = String()

  /// nondeterministic
  var info: String = String()

  var gasWanted: Int64 = 0

  var gasUsed: Int64 = 0

  var events: [Tendermint_Abci_Event] = []

  var codespace: String = String()

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_ResponseDeliverTx {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var code: UInt32 = 0

  var data: Data = Data()

  /// nondeterministic
  var log: String = String()

  /// nondeterministic
  var info: String = String()

  var gasWanted: Int64 = 0

  var gasUsed: Int64 = 0

  var events: [Tendermint_Abci_Event] = []

  var codespace: String = String()

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_ResponseEndBlock {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var validatorUpdates: [Tendermint_Abci_ValidatorUpdate] = []

  var consensusParamUpdates: Tendermint_Abci_ConsensusParams {
    get {return _consensusParamUpdates ?? Tendermint_Abci_ConsensusParams()}
    set {_consensusParamUpdates = newValue}
  }
  /// Returns true if `consensusParamUpdates` has been explicitly set.
  var hasConsensusParamUpdates: Bool {return self._consensusParamUpdates != nil}
  /// Clears the value of `consensusParamUpdates`. Subsequent reads from it will return its default value.
  mutating func clearConsensusParamUpdates() {self._consensusParamUpdates = nil}

  var events: [Tendermint_Abci_Event] = []

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _consensusParamUpdates: Tendermint_Abci_ConsensusParams? = nil
}

struct Tendermint_Abci_ResponseCommit {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  /// reserve 1
  var data: Data = Data()

  var retainHeight: Int64 = 0

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_ResponseListSnapshots {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var snapshots: [Tendermint_Abci_Snapshot] = []

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_ResponseOfferSnapshot {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var result: Tendermint_Abci_ResponseOfferSnapshot.Result = .unknown

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum Result: SwiftProtobuf.Enum {
    typealias RawValue = Int

    /// Unknown result, abort all snapshot restoration
    case unknown // = 0

    /// Snapshot accepted, apply chunks
    case accept // = 1

    /// Abort all snapshot restoration
    case abort // = 2

    /// Reject this specific snapshot, try others
    case reject // = 3

    /// Reject all snapshots of this format, try others
    case rejectFormat // = 4

    /// Reject all snapshots from the sender(s), try others
    case rejectSender // = 5
    case UNRECOGNIZED(Int)

    init() {
      self = .unknown
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .unknown
      case 1: self = .accept
      case 2: self = .abort
      case 3: self = .reject
      case 4: self = .rejectFormat
      case 5: self = .rejectSender
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .unknown: return 0
      case .accept: return 1
      case .abort: return 2
      case .reject: return 3
      case .rejectFormat: return 4
      case .rejectSender: return 5
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  init() {}
}

#if swift(>=4.2)

extension Tendermint_Abci_ResponseOfferSnapshot.Result: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [Tendermint_Abci_ResponseOfferSnapshot.Result] = [
    .unknown,
    .accept,
    .abort,
    .reject,
    .rejectFormat,
    .rejectSender,
  ]
}

#endif  // swift(>=4.2)

struct Tendermint_Abci_ResponseLoadSnapshotChunk {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var chunk: Data = Data()

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_ResponseApplySnapshotChunk {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var result: Tendermint_Abci_ResponseApplySnapshotChunk.Result = .unknown

  /// Chunks to refetch and reapply
  var refetchChunks: [UInt32] = []

  /// Chunk senders to reject and ban
  var rejectSenders: [String] = []

  var unknownFields = SwiftProtobuf.UnknownStorage()

  enum Result: SwiftProtobuf.Enum {
    typealias RawValue = Int

    /// Unknown result, abort all snapshot restoration
    case unknown // = 0

    /// Chunk successfully accepted
    case accept // = 1

    /// Abort all snapshot restoration
    case abort // = 2

    /// Retry chunk (combine with refetch and reject)
    case retry // = 3

    /// Retry snapshot (combine with refetch and reject)
    case retrySnapshot // = 4

    /// Reject this snapshot, try others
    case rejectSnapshot // = 5
    case UNRECOGNIZED(Int)

    init() {
      self = .unknown
    }

    init?(rawValue: Int) {
      switch rawValue {
      case 0: self = .unknown
      case 1: self = .accept
      case 2: self = .abort
      case 3: self = .retry
      case 4: self = .retrySnapshot
      case 5: self = .rejectSnapshot
      default: self = .UNRECOGNIZED(rawValue)
      }
    }

    var rawValue: Int {
      switch self {
      case .unknown: return 0
      case .accept: return 1
      case .abort: return 2
      case .retry: return 3
      case .retrySnapshot: return 4
      case .rejectSnapshot: return 5
      case .UNRECOGNIZED(let i): return i
      }
    }

  }

  init() {}
}

#if swift(>=4.2)

extension Tendermint_Abci_ResponseApplySnapshotChunk.Result: CaseIterable {
  // The compiler won't synthesize support with the UNRECOGNIZED case.
  static var allCases: [Tendermint_Abci_ResponseApplySnapshotChunk.Result] = [
    .unknown,
    .accept,
    .abort,
    .retry,
    .retrySnapshot,
    .rejectSnapshot,
  ]
}

#endif  // swift(>=4.2)

/// ConsensusParams contains all consensus-relevant parameters
/// that can be adjusted by the abci app
struct Tendermint_Abci_ConsensusParams {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var block: Tendermint_Abci_BlockParams {
    get {return _block ?? Tendermint_Abci_BlockParams()}
    set {_block = newValue}
  }
  /// Returns true if `block` has been explicitly set.
  var hasBlock: Bool {return self._block != nil}
  /// Clears the value of `block`. Subsequent reads from it will return its default value.
  mutating func clearBlock() {self._block = nil}

  var evidence: Tendermint_Types_EvidenceParams {
    get {return _evidence ?? Tendermint_Types_EvidenceParams()}
    set {_evidence = newValue}
  }
  /// Returns true if `evidence` has been explicitly set.
  var hasEvidence: Bool {return self._evidence != nil}
  /// Clears the value of `evidence`. Subsequent reads from it will return its default value.
  mutating func clearEvidence() {self._evidence = nil}

  var validator: Tendermint_Types_ValidatorParams {
    get {return _validator ?? Tendermint_Types_ValidatorParams()}
    set {_validator = newValue}
  }
  /// Returns true if `validator` has been explicitly set.
  var hasValidator: Bool {return self._validator != nil}
  /// Clears the value of `validator`. Subsequent reads from it will return its default value.
  mutating func clearValidator() {self._validator = nil}

  var version: Tendermint_Types_VersionParams {
    get {return _version ?? Tendermint_Types_VersionParams()}
    set {_version = newValue}
  }
  /// Returns true if `version` has been explicitly set.
  var hasVersion: Bool {return self._version != nil}
  /// Clears the value of `version`. Subsequent reads from it will return its default value.
  mutating func clearVersion() {self._version = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _block: Tendermint_Abci_BlockParams? = nil
  fileprivate var _evidence: Tendermint_Types_EvidenceParams? = nil
  fileprivate var _validator: Tendermint_Types_ValidatorParams? = nil
  fileprivate var _version: Tendermint_Types_VersionParams? = nil
}

/// BlockParams contains limits on the block size.
struct Tendermint_Abci_BlockParams {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  /// Note: must be greater than 0
  var maxBytes: Int64 = 0

  /// Note: must be greater or equal to -1
  var maxGas: Int64 = 0

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

struct Tendermint_Abci_LastCommitInfo {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var round: Int32 = 0

  var votes: [Tendermint_Abci_VoteInfo] = []

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

/// Event allows application developers to attach additional information to
/// ResponseBeginBlock, ResponseEndBlock, ResponseCheckTx and ResponseDeliverTx.
/// Later, transactions may be queried using these events.
struct Tendermint_Abci_Event {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var type: String = String()

  var attributes: [Tendermint_Abci_EventAttribute] = []

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

/// EventAttribute is a single key-value pair, associated with an event.
struct Tendermint_Abci_EventAttribute {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var key: Data = Data()

  var value: Data = Data()

  /// nondeterministic
  var index: Bool = false

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

/// TxResult contains results of executing the transaction.
///
/// One usage is indexing transaction results.
struct Tendermint_Abci_TxResult {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var height: Int64 = 0

  var index: UInt32 = 0

  var tx: Data = Data()

  var result: Tendermint_Abci_ResponseDeliverTx {
    get {return _result ?? Tendermint_Abci_ResponseDeliverTx()}
    set {_result = newValue}
  }
  /// Returns true if `result` has been explicitly set.
  var hasResult: Bool {return self._result != nil}
  /// Clears the value of `result`. Subsequent reads from it will return its default value.
  mutating func clearResult() {self._result = nil}

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _result: Tendermint_Abci_ResponseDeliverTx? = nil
}

/// Validator
struct Tendermint_Abci_Validator {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  /// The first 20 bytes of SHA256(public key)
  var address: Data = Data()

  /// PubKey pub_key = 2 [(gogoproto.nullable)=false];
  var power: Int64 = 0

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

/// ValidatorUpdate
struct Tendermint_Abci_ValidatorUpdate {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var pubKey: Tendermint_Crypto_PublicKey {
    get {return _pubKey ?? Tendermint_Crypto_PublicKey()}
    set {_pubKey = newValue}
  }
  /// Returns true if `pubKey` has been explicitly set.
  var hasPubKey: Bool {return self._pubKey != nil}
  /// Clears the value of `pubKey`. Subsequent reads from it will return its default value.
  mutating func clearPubKey() {self._pubKey = nil}

  var power: Int64 = 0

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _pubKey: Tendermint_Crypto_PublicKey? = nil
}

/// VoteInfo
struct Tendermint_Abci_VoteInfo {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var validator: Tendermint_Abci_Validator {
    get {return _validator ?? Tendermint_Abci_Validator()}
    set {_validator = newValue}
  }
  /// Returns true if `validator` has been explicitly set.
  var hasValidator: Bool {return self._validator != nil}
  /// Clears the value of `validator`. Subsequent reads from it will return its default value.
  mutating func clearValidator() {self._validator = nil}

  var signedLastBlock: Bool = false

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _validator: Tendermint_Abci_Validator? = nil
}

struct Tendermint_Abci_Evidence {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  var type: Tendermint_Abci_EvidenceType = .unknown

  /// The offending validator
  var validator: Tendermint_Abci_Validator {
    get {return _validator ?? Tendermint_Abci_Validator()}
    set {_validator = newValue}
  }
  /// Returns true if `validator` has been explicitly set.
  var hasValidator: Bool {return self._validator != nil}
  /// Clears the value of `validator`. Subsequent reads from it will return its default value.
  mutating func clearValidator() {self._validator = nil}

  /// The height when the offense occurred
  var height: Int64 = 0

  /// The corresponding time where the offense occurred
  var time: SwiftProtobuf.Google_Protobuf_Timestamp {
    get {return _time ?? SwiftProtobuf.Google_Protobuf_Timestamp()}
    set {_time = newValue}
  }
  /// Returns true if `time` has been explicitly set.
  var hasTime: Bool {return self._time != nil}
  /// Clears the value of `time`. Subsequent reads from it will return its default value.
  mutating func clearTime() {self._time = nil}

  /// Total voting power of the validator set in case the ABCI application does
  /// not store historical validators.
  /// https://github.com/tendermint/tendermint/issues/4581
  var totalVotingPower: Int64 = 0

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}

  fileprivate var _validator: Tendermint_Abci_Validator? = nil
  fileprivate var _time: SwiftProtobuf.Google_Protobuf_Timestamp? = nil
}

struct Tendermint_Abci_Snapshot {
  // SwiftProtobuf.Message conformance is added in an extension below. See the
  // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
  // methods supported on all messages.

  /// The height at which the snapshot was taken
  var height: UInt64 = 0

  /// The application-specific snapshot format
  var format: UInt32 = 0

  /// Number of chunks in the snapshot
  var chunks: UInt32 = 0

  /// Arbitrary snapshot hash, equal only if identical
  var hash: Data = Data()

  /// Arbitrary application metadata
  var metadata: Data = Data()

  var unknownFields = SwiftProtobuf.UnknownStorage()

  init() {}
}

// MARK: - Code below here is support for the SwiftProtobuf runtime.

fileprivate let _protobuf_package = "tendermint.abci"

extension Tendermint_Abci_CheckTxType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "NEW"),
    1: .same(proto: "RECHECK"),
  ]
}

extension Tendermint_Abci_EvidenceType: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "UNKNOWN"),
    1: .same(proto: "DUPLICATE_VOTE"),
    2: .same(proto: "LIGHT_CLIENT_ATTACK"),
  ]
}

extension Tendermint_Abci_Request: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".Request"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "echo"),
    2: .same(proto: "flush"),
    3: .same(proto: "info"),
    4: .standard(proto: "set_option"),
    5: .standard(proto: "init_chain"),
    6: .same(proto: "query"),
    7: .standard(proto: "begin_block"),
    8: .standard(proto: "check_tx"),
    9: .standard(proto: "deliver_tx"),
    10: .standard(proto: "end_block"),
    11: .same(proto: "commit"),
    12: .standard(proto: "list_snapshots"),
    13: .standard(proto: "offer_snapshot"),
    14: .standard(proto: "load_snapshot_chunk"),
    15: .standard(proto: "apply_snapshot_chunk"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try {
        var v: Tendermint_Abci_RequestEcho?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .echo(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .echo(v)}
      }()
      case 2: try {
        var v: Tendermint_Abci_RequestFlush?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .flush(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .flush(v)}
      }()
      case 3: try {
        var v: Tendermint_Abci_RequestInfo?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .info(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .info(v)}
      }()
      case 4: try {
        var v: Tendermint_Abci_RequestSetOption?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .setOption(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .setOption(v)}
      }()
      case 5: try {
        var v: Tendermint_Abci_RequestInitChain?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .initChain(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .initChain(v)}
      }()
      case 6: try {
        var v: Tendermint_Abci_RequestQuery?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .query(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .query(v)}
      }()
      case 7: try {
        var v: Tendermint_Abci_RequestBeginBlock?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .beginBlock(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .beginBlock(v)}
      }()
      case 8: try {
        var v: Tendermint_Abci_RequestCheckTx?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .checkTx(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .checkTx(v)}
      }()
      case 9: try {
        var v: Tendermint_Abci_RequestDeliverTx?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .deliverTx(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .deliverTx(v)}
      }()
      case 10: try {
        var v: Tendermint_Abci_RequestEndBlock?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .endBlock(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .endBlock(v)}
      }()
      case 11: try {
        var v: Tendermint_Abci_RequestCommit?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .commit(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .commit(v)}
      }()
      case 12: try {
        var v: Tendermint_Abci_RequestListSnapshots?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .listSnapshots(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .listSnapshots(v)}
      }()
      case 13: try {
        var v: Tendermint_Abci_RequestOfferSnapshot?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .offerSnapshot(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .offerSnapshot(v)}
      }()
      case 14: try {
        var v: Tendermint_Abci_RequestLoadSnapshotChunk?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .loadSnapshotChunk(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .loadSnapshotChunk(v)}
      }()
      case 15: try {
        var v: Tendermint_Abci_RequestApplySnapshotChunk?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .applySnapshotChunk(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .applySnapshotChunk(v)}
      }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every case branch when no optimizations are
    // enabled. https://github.com/apple/swift-protobuf/issues/1034
    switch self.value {
    case .echo?: try {
      guard case .echo(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
    }()
    case .flush?: try {
      guard case .flush(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
    }()
    case .info?: try {
      guard case .info(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
    }()
    case .setOption?: try {
      guard case .setOption(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
    }()
    case .initChain?: try {
      guard case .initChain(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 5)
    }()
    case .query?: try {
      guard case .query(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 6)
    }()
    case .beginBlock?: try {
      guard case .beginBlock(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 7)
    }()
    case .checkTx?: try {
      guard case .checkTx(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 8)
    }()
    case .deliverTx?: try {
      guard case .deliverTx(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 9)
    }()
    case .endBlock?: try {
      guard case .endBlock(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 10)
    }()
    case .commit?: try {
      guard case .commit(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 11)
    }()
    case .listSnapshots?: try {
      guard case .listSnapshots(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 12)
    }()
    case .offerSnapshot?: try {
      guard case .offerSnapshot(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 13)
    }()
    case .loadSnapshotChunk?: try {
      guard case .loadSnapshotChunk(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 14)
    }()
    case .applySnapshotChunk?: try {
      guard case .applySnapshotChunk(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 15)
    }()
    case nil: break
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_Request, rhs: Tendermint_Abci_Request) -> Bool {
    if lhs.value != rhs.value {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_RequestEcho: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".RequestEcho"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "message"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.message) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.message.isEmpty {
      try visitor.visitSingularStringField(value: self.message, fieldNumber: 1)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_RequestEcho, rhs: Tendermint_Abci_RequestEcho) -> Bool {
    if lhs.message != rhs.message {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_RequestFlush: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".RequestFlush"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let _ = try decoder.nextFieldNumber() {
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_RequestFlush, rhs: Tendermint_Abci_RequestFlush) -> Bool {
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_RequestInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".RequestInfo"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "version"),
    2: .standard(proto: "block_version"),
    3: .standard(proto: "p2p_version"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.version) }()
      case 2: try { try decoder.decodeSingularUInt64Field(value: &self.blockVersion) }()
      case 3: try { try decoder.decodeSingularUInt64Field(value: &self.p2PVersion) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.version.isEmpty {
      try visitor.visitSingularStringField(value: self.version, fieldNumber: 1)
    }
    if self.blockVersion != 0 {
      try visitor.visitSingularUInt64Field(value: self.blockVersion, fieldNumber: 2)
    }
    if self.p2PVersion != 0 {
      try visitor.visitSingularUInt64Field(value: self.p2PVersion, fieldNumber: 3)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_RequestInfo, rhs: Tendermint_Abci_RequestInfo) -> Bool {
    if lhs.version != rhs.version {return false}
    if lhs.blockVersion != rhs.blockVersion {return false}
    if lhs.p2PVersion != rhs.p2PVersion {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_RequestSetOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".RequestSetOption"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "key"),
    2: .same(proto: "value"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.key) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self.value) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.key.isEmpty {
      try visitor.visitSingularStringField(value: self.key, fieldNumber: 1)
    }
    if !self.value.isEmpty {
      try visitor.visitSingularStringField(value: self.value, fieldNumber: 2)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_RequestSetOption, rhs: Tendermint_Abci_RequestSetOption) -> Bool {
    if lhs.key != rhs.key {return false}
    if lhs.value != rhs.value {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_RequestInitChain: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".RequestInitChain"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "time"),
    2: .standard(proto: "chain_id"),
    3: .standard(proto: "consensus_params"),
    4: .same(proto: "validators"),
    5: .standard(proto: "app_state_bytes"),
    6: .standard(proto: "initial_height"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularMessageField(value: &self._time) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self.chainID) }()
      case 3: try { try decoder.decodeSingularMessageField(value: &self._consensusParams) }()
      case 4: try { try decoder.decodeRepeatedMessageField(value: &self.validators) }()
      case 5: try { try decoder.decodeSingularBytesField(value: &self.appStateBytes) }()
      case 6: try { try decoder.decodeSingularInt64Field(value: &self.initialHeight) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if let v = self._time {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
    }
    if !self.chainID.isEmpty {
      try visitor.visitSingularStringField(value: self.chainID, fieldNumber: 2)
    }
    if let v = self._consensusParams {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
    }
    if !self.validators.isEmpty {
      try visitor.visitRepeatedMessageField(value: self.validators, fieldNumber: 4)
    }
    if !self.appStateBytes.isEmpty {
      try visitor.visitSingularBytesField(value: self.appStateBytes, fieldNumber: 5)
    }
    if self.initialHeight != 0 {
      try visitor.visitSingularInt64Field(value: self.initialHeight, fieldNumber: 6)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_RequestInitChain, rhs: Tendermint_Abci_RequestInitChain) -> Bool {
    if lhs._time != rhs._time {return false}
    if lhs.chainID != rhs.chainID {return false}
    if lhs._consensusParams != rhs._consensusParams {return false}
    if lhs.validators != rhs.validators {return false}
    if lhs.appStateBytes != rhs.appStateBytes {return false}
    if lhs.initialHeight != rhs.initialHeight {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_RequestQuery: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".RequestQuery"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "data"),
    2: .same(proto: "path"),
    3: .same(proto: "height"),
    4: .same(proto: "prove"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularBytesField(value: &self.data) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self.path) }()
      case 3: try { try decoder.decodeSingularInt64Field(value: &self.height) }()
      case 4: try { try decoder.decodeSingularBoolField(value: &self.prove) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.data.isEmpty {
      try visitor.visitSingularBytesField(value: self.data, fieldNumber: 1)
    }
    if !self.path.isEmpty {
      try visitor.visitSingularStringField(value: self.path, fieldNumber: 2)
    }
    if self.height != 0 {
      try visitor.visitSingularInt64Field(value: self.height, fieldNumber: 3)
    }
    if self.prove != false {
      try visitor.visitSingularBoolField(value: self.prove, fieldNumber: 4)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_RequestQuery, rhs: Tendermint_Abci_RequestQuery) -> Bool {
    if lhs.data != rhs.data {return false}
    if lhs.path != rhs.path {return false}
    if lhs.height != rhs.height {return false}
    if lhs.prove != rhs.prove {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_RequestBeginBlock: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".RequestBeginBlock"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "hash"),
    2: .same(proto: "header"),
    3: .standard(proto: "last_commit_info"),
    4: .standard(proto: "byzantine_validators"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularBytesField(value: &self.hash) }()
      case 2: try { try decoder.decodeSingularMessageField(value: &self._header) }()
      case 3: try { try decoder.decodeSingularMessageField(value: &self._lastCommitInfo) }()
      case 4: try { try decoder.decodeRepeatedMessageField(value: &self.byzantineValidators) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.hash.isEmpty {
      try visitor.visitSingularBytesField(value: self.hash, fieldNumber: 1)
    }
    if let v = self._header {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
    }
    if let v = self._lastCommitInfo {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
    }
    if !self.byzantineValidators.isEmpty {
      try visitor.visitRepeatedMessageField(value: self.byzantineValidators, fieldNumber: 4)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_RequestBeginBlock, rhs: Tendermint_Abci_RequestBeginBlock) -> Bool {
    if lhs.hash != rhs.hash {return false}
    if lhs._header != rhs._header {return false}
    if lhs._lastCommitInfo != rhs._lastCommitInfo {return false}
    if lhs.byzantineValidators != rhs.byzantineValidators {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_RequestCheckTx: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".RequestCheckTx"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "tx"),
    2: .same(proto: "type"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularBytesField(value: &self.tx) }()
      case 2: try { try decoder.decodeSingularEnumField(value: &self.type) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.tx.isEmpty {
      try visitor.visitSingularBytesField(value: self.tx, fieldNumber: 1)
    }
    if self.type != .new {
      try visitor.visitSingularEnumField(value: self.type, fieldNumber: 2)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_RequestCheckTx, rhs: Tendermint_Abci_RequestCheckTx) -> Bool {
    if lhs.tx != rhs.tx {return false}
    if lhs.type != rhs.type {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_RequestDeliverTx: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".RequestDeliverTx"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "tx"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularBytesField(value: &self.tx) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.tx.isEmpty {
      try visitor.visitSingularBytesField(value: self.tx, fieldNumber: 1)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_RequestDeliverTx, rhs: Tendermint_Abci_RequestDeliverTx) -> Bool {
    if lhs.tx != rhs.tx {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_RequestEndBlock: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".RequestEndBlock"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "height"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularInt64Field(value: &self.height) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.height != 0 {
      try visitor.visitSingularInt64Field(value: self.height, fieldNumber: 1)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_RequestEndBlock, rhs: Tendermint_Abci_RequestEndBlock) -> Bool {
    if lhs.height != rhs.height {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_RequestCommit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".RequestCommit"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let _ = try decoder.nextFieldNumber() {
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_RequestCommit, rhs: Tendermint_Abci_RequestCommit) -> Bool {
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_RequestListSnapshots: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".RequestListSnapshots"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let _ = try decoder.nextFieldNumber() {
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_RequestListSnapshots, rhs: Tendermint_Abci_RequestListSnapshots) -> Bool {
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_RequestOfferSnapshot: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".RequestOfferSnapshot"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "snapshot"),
    2: .standard(proto: "app_hash"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularMessageField(value: &self._snapshot) }()
      case 2: try { try decoder.decodeSingularBytesField(value: &self.appHash) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if let v = self._snapshot {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
    }
    if !self.appHash.isEmpty {
      try visitor.visitSingularBytesField(value: self.appHash, fieldNumber: 2)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_RequestOfferSnapshot, rhs: Tendermint_Abci_RequestOfferSnapshot) -> Bool {
    if lhs._snapshot != rhs._snapshot {return false}
    if lhs.appHash != rhs.appHash {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_RequestLoadSnapshotChunk: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".RequestLoadSnapshotChunk"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "height"),
    2: .same(proto: "format"),
    3: .same(proto: "chunk"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularUInt64Field(value: &self.height) }()
      case 2: try { try decoder.decodeSingularUInt32Field(value: &self.format) }()
      case 3: try { try decoder.decodeSingularUInt32Field(value: &self.chunk) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.height != 0 {
      try visitor.visitSingularUInt64Field(value: self.height, fieldNumber: 1)
    }
    if self.format != 0 {
      try visitor.visitSingularUInt32Field(value: self.format, fieldNumber: 2)
    }
    if self.chunk != 0 {
      try visitor.visitSingularUInt32Field(value: self.chunk, fieldNumber: 3)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_RequestLoadSnapshotChunk, rhs: Tendermint_Abci_RequestLoadSnapshotChunk) -> Bool {
    if lhs.height != rhs.height {return false}
    if lhs.format != rhs.format {return false}
    if lhs.chunk != rhs.chunk {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_RequestApplySnapshotChunk: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".RequestApplySnapshotChunk"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "index"),
    2: .same(proto: "chunk"),
    3: .same(proto: "sender"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularUInt32Field(value: &self.index) }()
      case 2: try { try decoder.decodeSingularBytesField(value: &self.chunk) }()
      case 3: try { try decoder.decodeSingularStringField(value: &self.sender) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.index != 0 {
      try visitor.visitSingularUInt32Field(value: self.index, fieldNumber: 1)
    }
    if !self.chunk.isEmpty {
      try visitor.visitSingularBytesField(value: self.chunk, fieldNumber: 2)
    }
    if !self.sender.isEmpty {
      try visitor.visitSingularStringField(value: self.sender, fieldNumber: 3)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_RequestApplySnapshotChunk, rhs: Tendermint_Abci_RequestApplySnapshotChunk) -> Bool {
    if lhs.index != rhs.index {return false}
    if lhs.chunk != rhs.chunk {return false}
    if lhs.sender != rhs.sender {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_Response: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".Response"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "exception"),
    2: .same(proto: "echo"),
    3: .same(proto: "flush"),
    4: .same(proto: "info"),
    5: .standard(proto: "set_option"),
    6: .standard(proto: "init_chain"),
    7: .same(proto: "query"),
    8: .standard(proto: "begin_block"),
    9: .standard(proto: "check_tx"),
    10: .standard(proto: "deliver_tx"),
    11: .standard(proto: "end_block"),
    12: .same(proto: "commit"),
    13: .standard(proto: "list_snapshots"),
    14: .standard(proto: "offer_snapshot"),
    15: .standard(proto: "load_snapshot_chunk"),
    16: .standard(proto: "apply_snapshot_chunk"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try {
        var v: Tendermint_Abci_ResponseException?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .exception(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .exception(v)}
      }()
      case 2: try {
        var v: Tendermint_Abci_ResponseEcho?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .echo(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .echo(v)}
      }()
      case 3: try {
        var v: Tendermint_Abci_ResponseFlush?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .flush(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .flush(v)}
      }()
      case 4: try {
        var v: Tendermint_Abci_ResponseInfo?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .info(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .info(v)}
      }()
      case 5: try {
        var v: Tendermint_Abci_ResponseSetOption?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .setOption(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .setOption(v)}
      }()
      case 6: try {
        var v: Tendermint_Abci_ResponseInitChain?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .initChain(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .initChain(v)}
      }()
      case 7: try {
        var v: Tendermint_Abci_ResponseQuery?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .query(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .query(v)}
      }()
      case 8: try {
        var v: Tendermint_Abci_ResponseBeginBlock?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .beginBlock(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .beginBlock(v)}
      }()
      case 9: try {
        var v: Tendermint_Abci_ResponseCheckTx?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .checkTx(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .checkTx(v)}
      }()
      case 10: try {
        var v: Tendermint_Abci_ResponseDeliverTx?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .deliverTx(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .deliverTx(v)}
      }()
      case 11: try {
        var v: Tendermint_Abci_ResponseEndBlock?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .endBlock(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .endBlock(v)}
      }()
      case 12: try {
        var v: Tendermint_Abci_ResponseCommit?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .commit(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .commit(v)}
      }()
      case 13: try {
        var v: Tendermint_Abci_ResponseListSnapshots?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .listSnapshots(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .listSnapshots(v)}
      }()
      case 14: try {
        var v: Tendermint_Abci_ResponseOfferSnapshot?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .offerSnapshot(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .offerSnapshot(v)}
      }()
      case 15: try {
        var v: Tendermint_Abci_ResponseLoadSnapshotChunk?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .loadSnapshotChunk(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .loadSnapshotChunk(v)}
      }()
      case 16: try {
        var v: Tendermint_Abci_ResponseApplySnapshotChunk?
        if let current = self.value {
          try decoder.handleConflictingOneOf()
          if case .applySnapshotChunk(let m) = current {v = m}
        }
        try decoder.decodeSingularMessageField(value: &v)
        if let v = v {self.value = .applySnapshotChunk(v)}
      }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    // The use of inline closures is to circumvent an issue where the compiler
    // allocates stack space for every case branch when no optimizations are
    // enabled. https://github.com/apple/swift-protobuf/issues/1034
    switch self.value {
    case .exception?: try {
      guard case .exception(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
    }()
    case .echo?: try {
      guard case .echo(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
    }()
    case .flush?: try {
      guard case .flush(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
    }()
    case .info?: try {
      guard case .info(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
    }()
    case .setOption?: try {
      guard case .setOption(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 5)
    }()
    case .initChain?: try {
      guard case .initChain(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 6)
    }()
    case .query?: try {
      guard case .query(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 7)
    }()
    case .beginBlock?: try {
      guard case .beginBlock(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 8)
    }()
    case .checkTx?: try {
      guard case .checkTx(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 9)
    }()
    case .deliverTx?: try {
      guard case .deliverTx(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 10)
    }()
    case .endBlock?: try {
      guard case .endBlock(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 11)
    }()
    case .commit?: try {
      guard case .commit(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 12)
    }()
    case .listSnapshots?: try {
      guard case .listSnapshots(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 13)
    }()
    case .offerSnapshot?: try {
      guard case .offerSnapshot(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 14)
    }()
    case .loadSnapshotChunk?: try {
      guard case .loadSnapshotChunk(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 15)
    }()
    case .applySnapshotChunk?: try {
      guard case .applySnapshotChunk(let v)? = self.value else { preconditionFailure() }
      try visitor.visitSingularMessageField(value: v, fieldNumber: 16)
    }()
    case nil: break
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_Response, rhs: Tendermint_Abci_Response) -> Bool {
    if lhs.value != rhs.value {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseException: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ResponseException"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "error"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.error) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.error.isEmpty {
      try visitor.visitSingularStringField(value: self.error, fieldNumber: 1)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ResponseException, rhs: Tendermint_Abci_ResponseException) -> Bool {
    if lhs.error != rhs.error {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseEcho: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ResponseEcho"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "message"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.message) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.message.isEmpty {
      try visitor.visitSingularStringField(value: self.message, fieldNumber: 1)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ResponseEcho, rhs: Tendermint_Abci_ResponseEcho) -> Bool {
    if lhs.message != rhs.message {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseFlush: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ResponseFlush"
  static let _protobuf_nameMap = SwiftProtobuf._NameMap()

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let _ = try decoder.nextFieldNumber() {
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ResponseFlush, rhs: Tendermint_Abci_ResponseFlush) -> Bool {
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ResponseInfo"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "data"),
    2: .same(proto: "version"),
    3: .standard(proto: "app_version"),
    4: .standard(proto: "last_block_height"),
    5: .standard(proto: "last_block_app_hash"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.data) }()
      case 2: try { try decoder.decodeSingularStringField(value: &self.version) }()
      case 3: try { try decoder.decodeSingularUInt64Field(value: &self.appVersion) }()
      case 4: try { try decoder.decodeSingularInt64Field(value: &self.lastBlockHeight) }()
      case 5: try { try decoder.decodeSingularBytesField(value: &self.lastBlockAppHash) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.data.isEmpty {
      try visitor.visitSingularStringField(value: self.data, fieldNumber: 1)
    }
    if !self.version.isEmpty {
      try visitor.visitSingularStringField(value: self.version, fieldNumber: 2)
    }
    if self.appVersion != 0 {
      try visitor.visitSingularUInt64Field(value: self.appVersion, fieldNumber: 3)
    }
    if self.lastBlockHeight != 0 {
      try visitor.visitSingularInt64Field(value: self.lastBlockHeight, fieldNumber: 4)
    }
    if !self.lastBlockAppHash.isEmpty {
      try visitor.visitSingularBytesField(value: self.lastBlockAppHash, fieldNumber: 5)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ResponseInfo, rhs: Tendermint_Abci_ResponseInfo) -> Bool {
    if lhs.data != rhs.data {return false}
    if lhs.version != rhs.version {return false}
    if lhs.appVersion != rhs.appVersion {return false}
    if lhs.lastBlockHeight != rhs.lastBlockHeight {return false}
    if lhs.lastBlockAppHash != rhs.lastBlockAppHash {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseSetOption: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ResponseSetOption"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "code"),
    3: .same(proto: "log"),
    4: .same(proto: "info"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularUInt32Field(value: &self.code) }()
      case 3: try { try decoder.decodeSingularStringField(value: &self.log) }()
      case 4: try { try decoder.decodeSingularStringField(value: &self.info) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.code != 0 {
      try visitor.visitSingularUInt32Field(value: self.code, fieldNumber: 1)
    }
    if !self.log.isEmpty {
      try visitor.visitSingularStringField(value: self.log, fieldNumber: 3)
    }
    if !self.info.isEmpty {
      try visitor.visitSingularStringField(value: self.info, fieldNumber: 4)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ResponseSetOption, rhs: Tendermint_Abci_ResponseSetOption) -> Bool {
    if lhs.code != rhs.code {return false}
    if lhs.log != rhs.log {return false}
    if lhs.info != rhs.info {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseInitChain: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ResponseInitChain"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .standard(proto: "consensus_params"),
    2: .same(proto: "validators"),
    3: .standard(proto: "app_hash"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularMessageField(value: &self._consensusParams) }()
      case 2: try { try decoder.decodeRepeatedMessageField(value: &self.validators) }()
      case 3: try { try decoder.decodeSingularBytesField(value: &self.appHash) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if let v = self._consensusParams {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
    }
    if !self.validators.isEmpty {
      try visitor.visitRepeatedMessageField(value: self.validators, fieldNumber: 2)
    }
    if !self.appHash.isEmpty {
      try visitor.visitSingularBytesField(value: self.appHash, fieldNumber: 3)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ResponseInitChain, rhs: Tendermint_Abci_ResponseInitChain) -> Bool {
    if lhs._consensusParams != rhs._consensusParams {return false}
    if lhs.validators != rhs.validators {return false}
    if lhs.appHash != rhs.appHash {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseQuery: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ResponseQuery"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "code"),
    3: .same(proto: "log"),
    4: .same(proto: "info"),
    5: .same(proto: "index"),
    6: .same(proto: "key"),
    7: .same(proto: "value"),
    8: .standard(proto: "proof_ops"),
    9: .same(proto: "height"),
    10: .same(proto: "codespace"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularUInt32Field(value: &self.code) }()
      case 3: try { try decoder.decodeSingularStringField(value: &self.log) }()
      case 4: try { try decoder.decodeSingularStringField(value: &self.info) }()
      case 5: try { try decoder.decodeSingularInt64Field(value: &self.index) }()
      case 6: try { try decoder.decodeSingularBytesField(value: &self.key) }()
      case 7: try { try decoder.decodeSingularBytesField(value: &self.value) }()
      case 8: try { try decoder.decodeSingularMessageField(value: &self._proofOps) }()
      case 9: try { try decoder.decodeSingularInt64Field(value: &self.height) }()
      case 10: try { try decoder.decodeSingularStringField(value: &self.codespace) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.code != 0 {
      try visitor.visitSingularUInt32Field(value: self.code, fieldNumber: 1)
    }
    if !self.log.isEmpty {
      try visitor.visitSingularStringField(value: self.log, fieldNumber: 3)
    }
    if !self.info.isEmpty {
      try visitor.visitSingularStringField(value: self.info, fieldNumber: 4)
    }
    if self.index != 0 {
      try visitor.visitSingularInt64Field(value: self.index, fieldNumber: 5)
    }
    if !self.key.isEmpty {
      try visitor.visitSingularBytesField(value: self.key, fieldNumber: 6)
    }
    if !self.value.isEmpty {
      try visitor.visitSingularBytesField(value: self.value, fieldNumber: 7)
    }
    if let v = self._proofOps {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 8)
    }
    if self.height != 0 {
      try visitor.visitSingularInt64Field(value: self.height, fieldNumber: 9)
    }
    if !self.codespace.isEmpty {
      try visitor.visitSingularStringField(value: self.codespace, fieldNumber: 10)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ResponseQuery, rhs: Tendermint_Abci_ResponseQuery) -> Bool {
    if lhs.code != rhs.code {return false}
    if lhs.log != rhs.log {return false}
    if lhs.info != rhs.info {return false}
    if lhs.index != rhs.index {return false}
    if lhs.key != rhs.key {return false}
    if lhs.value != rhs.value {return false}
    if lhs._proofOps != rhs._proofOps {return false}
    if lhs.height != rhs.height {return false}
    if lhs.codespace != rhs.codespace {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseBeginBlock: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ResponseBeginBlock"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "events"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeRepeatedMessageField(value: &self.events) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.events.isEmpty {
      try visitor.visitRepeatedMessageField(value: self.events, fieldNumber: 1)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ResponseBeginBlock, rhs: Tendermint_Abci_ResponseBeginBlock) -> Bool {
    if lhs.events != rhs.events {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseCheckTx: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ResponseCheckTx"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "code"),
    2: .same(proto: "data"),
    3: .same(proto: "log"),
    4: .same(proto: "info"),
    5: .same(proto: "gas_wanted"),
    6: .same(proto: "gas_used"),
    7: .same(proto: "events"),
    8: .same(proto: "codespace"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularUInt32Field(value: &self.code) }()
      case 2: try { try decoder.decodeSingularBytesField(value: &self.data) }()
      case 3: try { try decoder.decodeSingularStringField(value: &self.log) }()
      case 4: try { try decoder.decodeSingularStringField(value: &self.info) }()
      case 5: try { try decoder.decodeSingularInt64Field(value: &self.gasWanted) }()
      case 6: try { try decoder.decodeSingularInt64Field(value: &self.gasUsed) }()
      case 7: try { try decoder.decodeRepeatedMessageField(value: &self.events) }()
      case 8: try { try decoder.decodeSingularStringField(value: &self.codespace) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.code != 0 {
      try visitor.visitSingularUInt32Field(value: self.code, fieldNumber: 1)
    }
    if !self.data.isEmpty {
      try visitor.visitSingularBytesField(value: self.data, fieldNumber: 2)
    }
    if !self.log.isEmpty {
      try visitor.visitSingularStringField(value: self.log, fieldNumber: 3)
    }
    if !self.info.isEmpty {
      try visitor.visitSingularStringField(value: self.info, fieldNumber: 4)
    }
    if self.gasWanted != 0 {
      try visitor.visitSingularInt64Field(value: self.gasWanted, fieldNumber: 5)
    }
    if self.gasUsed != 0 {
      try visitor.visitSingularInt64Field(value: self.gasUsed, fieldNumber: 6)
    }
    if !self.events.isEmpty {
      try visitor.visitRepeatedMessageField(value: self.events, fieldNumber: 7)
    }
    if !self.codespace.isEmpty {
      try visitor.visitSingularStringField(value: self.codespace, fieldNumber: 8)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ResponseCheckTx, rhs: Tendermint_Abci_ResponseCheckTx) -> Bool {
    if lhs.code != rhs.code {return false}
    if lhs.data != rhs.data {return false}
    if lhs.log != rhs.log {return false}
    if lhs.info != rhs.info {return false}
    if lhs.gasWanted != rhs.gasWanted {return false}
    if lhs.gasUsed != rhs.gasUsed {return false}
    if lhs.events != rhs.events {return false}
    if lhs.codespace != rhs.codespace {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseDeliverTx: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ResponseDeliverTx"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "code"),
    2: .same(proto: "data"),
    3: .same(proto: "log"),
    4: .same(proto: "info"),
    5: .same(proto: "gas_wanted"),
    6: .same(proto: "gas_used"),
    7: .same(proto: "events"),
    8: .same(proto: "codespace"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularUInt32Field(value: &self.code) }()
      case 2: try { try decoder.decodeSingularBytesField(value: &self.data) }()
      case 3: try { try decoder.decodeSingularStringField(value: &self.log) }()
      case 4: try { try decoder.decodeSingularStringField(value: &self.info) }()
      case 5: try { try decoder.decodeSingularInt64Field(value: &self.gasWanted) }()
      case 6: try { try decoder.decodeSingularInt64Field(value: &self.gasUsed) }()
      case 7: try { try decoder.decodeRepeatedMessageField(value: &self.events) }()
      case 8: try { try decoder.decodeSingularStringField(value: &self.codespace) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.code != 0 {
      try visitor.visitSingularUInt32Field(value: self.code, fieldNumber: 1)
    }
    if !self.data.isEmpty {
      try visitor.visitSingularBytesField(value: self.data, fieldNumber: 2)
    }
    if !self.log.isEmpty {
      try visitor.visitSingularStringField(value: self.log, fieldNumber: 3)
    }
    if !self.info.isEmpty {
      try visitor.visitSingularStringField(value: self.info, fieldNumber: 4)
    }
    if self.gasWanted != 0 {
      try visitor.visitSingularInt64Field(value: self.gasWanted, fieldNumber: 5)
    }
    if self.gasUsed != 0 {
      try visitor.visitSingularInt64Field(value: self.gasUsed, fieldNumber: 6)
    }
    if !self.events.isEmpty {
      try visitor.visitRepeatedMessageField(value: self.events, fieldNumber: 7)
    }
    if !self.codespace.isEmpty {
      try visitor.visitSingularStringField(value: self.codespace, fieldNumber: 8)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ResponseDeliverTx, rhs: Tendermint_Abci_ResponseDeliverTx) -> Bool {
    if lhs.code != rhs.code {return false}
    if lhs.data != rhs.data {return false}
    if lhs.log != rhs.log {return false}
    if lhs.info != rhs.info {return false}
    if lhs.gasWanted != rhs.gasWanted {return false}
    if lhs.gasUsed != rhs.gasUsed {return false}
    if lhs.events != rhs.events {return false}
    if lhs.codespace != rhs.codespace {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseEndBlock: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ResponseEndBlock"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .standard(proto: "validator_updates"),
    2: .standard(proto: "consensus_param_updates"),
    3: .same(proto: "events"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeRepeatedMessageField(value: &self.validatorUpdates) }()
      case 2: try { try decoder.decodeSingularMessageField(value: &self._consensusParamUpdates) }()
      case 3: try { try decoder.decodeRepeatedMessageField(value: &self.events) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.validatorUpdates.isEmpty {
      try visitor.visitRepeatedMessageField(value: self.validatorUpdates, fieldNumber: 1)
    }
    if let v = self._consensusParamUpdates {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
    }
    if !self.events.isEmpty {
      try visitor.visitRepeatedMessageField(value: self.events, fieldNumber: 3)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ResponseEndBlock, rhs: Tendermint_Abci_ResponseEndBlock) -> Bool {
    if lhs.validatorUpdates != rhs.validatorUpdates {return false}
    if lhs._consensusParamUpdates != rhs._consensusParamUpdates {return false}
    if lhs.events != rhs.events {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseCommit: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ResponseCommit"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    2: .same(proto: "data"),
    3: .standard(proto: "retain_height"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 2: try { try decoder.decodeSingularBytesField(value: &self.data) }()
      case 3: try { try decoder.decodeSingularInt64Field(value: &self.retainHeight) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.data.isEmpty {
      try visitor.visitSingularBytesField(value: self.data, fieldNumber: 2)
    }
    if self.retainHeight != 0 {
      try visitor.visitSingularInt64Field(value: self.retainHeight, fieldNumber: 3)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ResponseCommit, rhs: Tendermint_Abci_ResponseCommit) -> Bool {
    if lhs.data != rhs.data {return false}
    if lhs.retainHeight != rhs.retainHeight {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseListSnapshots: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ResponseListSnapshots"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "snapshots"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeRepeatedMessageField(value: &self.snapshots) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.snapshots.isEmpty {
      try visitor.visitRepeatedMessageField(value: self.snapshots, fieldNumber: 1)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ResponseListSnapshots, rhs: Tendermint_Abci_ResponseListSnapshots) -> Bool {
    if lhs.snapshots != rhs.snapshots {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseOfferSnapshot: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ResponseOfferSnapshot"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "result"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularEnumField(value: &self.result) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.result != .unknown {
      try visitor.visitSingularEnumField(value: self.result, fieldNumber: 1)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ResponseOfferSnapshot, rhs: Tendermint_Abci_ResponseOfferSnapshot) -> Bool {
    if lhs.result != rhs.result {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseOfferSnapshot.Result: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "UNKNOWN"),
    1: .same(proto: "ACCEPT"),
    2: .same(proto: "ABORT"),
    3: .same(proto: "REJECT"),
    4: .same(proto: "REJECT_FORMAT"),
    5: .same(proto: "REJECT_SENDER"),
  ]
}

extension Tendermint_Abci_ResponseLoadSnapshotChunk: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ResponseLoadSnapshotChunk"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "chunk"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularBytesField(value: &self.chunk) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.chunk.isEmpty {
      try visitor.visitSingularBytesField(value: self.chunk, fieldNumber: 1)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ResponseLoadSnapshotChunk, rhs: Tendermint_Abci_ResponseLoadSnapshotChunk) -> Bool {
    if lhs.chunk != rhs.chunk {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseApplySnapshotChunk: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ResponseApplySnapshotChunk"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "result"),
    2: .standard(proto: "refetch_chunks"),
    3: .standard(proto: "reject_senders"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularEnumField(value: &self.result) }()
      case 2: try { try decoder.decodeRepeatedUInt32Field(value: &self.refetchChunks) }()
      case 3: try { try decoder.decodeRepeatedStringField(value: &self.rejectSenders) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.result != .unknown {
      try visitor.visitSingularEnumField(value: self.result, fieldNumber: 1)
    }
    if !self.refetchChunks.isEmpty {
      try visitor.visitPackedUInt32Field(value: self.refetchChunks, fieldNumber: 2)
    }
    if !self.rejectSenders.isEmpty {
      try visitor.visitRepeatedStringField(value: self.rejectSenders, fieldNumber: 3)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ResponseApplySnapshotChunk, rhs: Tendermint_Abci_ResponseApplySnapshotChunk) -> Bool {
    if lhs.result != rhs.result {return false}
    if lhs.refetchChunks != rhs.refetchChunks {return false}
    if lhs.rejectSenders != rhs.rejectSenders {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ResponseApplySnapshotChunk.Result: SwiftProtobuf._ProtoNameProviding {
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    0: .same(proto: "UNKNOWN"),
    1: .same(proto: "ACCEPT"),
    2: .same(proto: "ABORT"),
    3: .same(proto: "RETRY"),
    4: .same(proto: "RETRY_SNAPSHOT"),
    5: .same(proto: "REJECT_SNAPSHOT"),
  ]
}

extension Tendermint_Abci_ConsensusParams: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ConsensusParams"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "block"),
    2: .same(proto: "evidence"),
    3: .same(proto: "validator"),
    4: .same(proto: "version"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularMessageField(value: &self._block) }()
      case 2: try { try decoder.decodeSingularMessageField(value: &self._evidence) }()
      case 3: try { try decoder.decodeSingularMessageField(value: &self._validator) }()
      case 4: try { try decoder.decodeSingularMessageField(value: &self._version) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if let v = self._block {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
    }
    if let v = self._evidence {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
    }
    if let v = self._validator {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 3)
    }
    if let v = self._version {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ConsensusParams, rhs: Tendermint_Abci_ConsensusParams) -> Bool {
    if lhs._block != rhs._block {return false}
    if lhs._evidence != rhs._evidence {return false}
    if lhs._validator != rhs._validator {return false}
    if lhs._version != rhs._version {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_BlockParams: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".BlockParams"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .standard(proto: "max_bytes"),
    2: .standard(proto: "max_gas"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularInt64Field(value: &self.maxBytes) }()
      case 2: try { try decoder.decodeSingularInt64Field(value: &self.maxGas) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.maxBytes != 0 {
      try visitor.visitSingularInt64Field(value: self.maxBytes, fieldNumber: 1)
    }
    if self.maxGas != 0 {
      try visitor.visitSingularInt64Field(value: self.maxGas, fieldNumber: 2)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_BlockParams, rhs: Tendermint_Abci_BlockParams) -> Bool {
    if lhs.maxBytes != rhs.maxBytes {return false}
    if lhs.maxGas != rhs.maxGas {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_LastCommitInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".LastCommitInfo"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "round"),
    2: .same(proto: "votes"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularInt32Field(value: &self.round) }()
      case 2: try { try decoder.decodeRepeatedMessageField(value: &self.votes) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.round != 0 {
      try visitor.visitSingularInt32Field(value: self.round, fieldNumber: 1)
    }
    if !self.votes.isEmpty {
      try visitor.visitRepeatedMessageField(value: self.votes, fieldNumber: 2)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_LastCommitInfo, rhs: Tendermint_Abci_LastCommitInfo) -> Bool {
    if lhs.round != rhs.round {return false}
    if lhs.votes != rhs.votes {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_Event: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".Event"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "type"),
    2: .same(proto: "attributes"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularStringField(value: &self.type) }()
      case 2: try { try decoder.decodeRepeatedMessageField(value: &self.attributes) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.type.isEmpty {
      try visitor.visitSingularStringField(value: self.type, fieldNumber: 1)
    }
    if !self.attributes.isEmpty {
      try visitor.visitRepeatedMessageField(value: self.attributes, fieldNumber: 2)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_Event, rhs: Tendermint_Abci_Event) -> Bool {
    if lhs.type != rhs.type {return false}
    if lhs.attributes != rhs.attributes {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_EventAttribute: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".EventAttribute"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "key"),
    2: .same(proto: "value"),
    3: .same(proto: "index"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularBytesField(value: &self.key) }()
      case 2: try { try decoder.decodeSingularBytesField(value: &self.value) }()
      case 3: try { try decoder.decodeSingularBoolField(value: &self.index) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.key.isEmpty {
      try visitor.visitSingularBytesField(value: self.key, fieldNumber: 1)
    }
    if !self.value.isEmpty {
      try visitor.visitSingularBytesField(value: self.value, fieldNumber: 2)
    }
    if self.index != false {
      try visitor.visitSingularBoolField(value: self.index, fieldNumber: 3)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_EventAttribute, rhs: Tendermint_Abci_EventAttribute) -> Bool {
    if lhs.key != rhs.key {return false}
    if lhs.value != rhs.value {return false}
    if lhs.index != rhs.index {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_TxResult: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".TxResult"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "height"),
    2: .same(proto: "index"),
    3: .same(proto: "tx"),
    4: .same(proto: "result"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularInt64Field(value: &self.height) }()
      case 2: try { try decoder.decodeSingularUInt32Field(value: &self.index) }()
      case 3: try { try decoder.decodeSingularBytesField(value: &self.tx) }()
      case 4: try { try decoder.decodeSingularMessageField(value: &self._result) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.height != 0 {
      try visitor.visitSingularInt64Field(value: self.height, fieldNumber: 1)
    }
    if self.index != 0 {
      try visitor.visitSingularUInt32Field(value: self.index, fieldNumber: 2)
    }
    if !self.tx.isEmpty {
      try visitor.visitSingularBytesField(value: self.tx, fieldNumber: 3)
    }
    if let v = self._result {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_TxResult, rhs: Tendermint_Abci_TxResult) -> Bool {
    if lhs.height != rhs.height {return false}
    if lhs.index != rhs.index {return false}
    if lhs.tx != rhs.tx {return false}
    if lhs._result != rhs._result {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_Validator: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".Validator"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "address"),
    3: .same(proto: "power"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularBytesField(value: &self.address) }()
      case 3: try { try decoder.decodeSingularInt64Field(value: &self.power) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if !self.address.isEmpty {
      try visitor.visitSingularBytesField(value: self.address, fieldNumber: 1)
    }
    if self.power != 0 {
      try visitor.visitSingularInt64Field(value: self.power, fieldNumber: 3)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_Validator, rhs: Tendermint_Abci_Validator) -> Bool {
    if lhs.address != rhs.address {return false}
    if lhs.power != rhs.power {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_ValidatorUpdate: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".ValidatorUpdate"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .standard(proto: "pub_key"),
    2: .same(proto: "power"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularMessageField(value: &self._pubKey) }()
      case 2: try { try decoder.decodeSingularInt64Field(value: &self.power) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if let v = self._pubKey {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
    }
    if self.power != 0 {
      try visitor.visitSingularInt64Field(value: self.power, fieldNumber: 2)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_ValidatorUpdate, rhs: Tendermint_Abci_ValidatorUpdate) -> Bool {
    if lhs._pubKey != rhs._pubKey {return false}
    if lhs.power != rhs.power {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_VoteInfo: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".VoteInfo"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "validator"),
    2: .standard(proto: "signed_last_block"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularMessageField(value: &self._validator) }()
      case 2: try { try decoder.decodeSingularBoolField(value: &self.signedLastBlock) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if let v = self._validator {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
    }
    if self.signedLastBlock != false {
      try visitor.visitSingularBoolField(value: self.signedLastBlock, fieldNumber: 2)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_VoteInfo, rhs: Tendermint_Abci_VoteInfo) -> Bool {
    if lhs._validator != rhs._validator {return false}
    if lhs.signedLastBlock != rhs.signedLastBlock {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_Evidence: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".Evidence"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "type"),
    2: .same(proto: "validator"),
    3: .same(proto: "height"),
    4: .same(proto: "time"),
    5: .standard(proto: "total_voting_power"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularEnumField(value: &self.type) }()
      case 2: try { try decoder.decodeSingularMessageField(value: &self._validator) }()
      case 3: try { try decoder.decodeSingularInt64Field(value: &self.height) }()
      case 4: try { try decoder.decodeSingularMessageField(value: &self._time) }()
      case 5: try { try decoder.decodeSingularInt64Field(value: &self.totalVotingPower) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.type != .unknown {
      try visitor.visitSingularEnumField(value: self.type, fieldNumber: 1)
    }
    if let v = self._validator {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 2)
    }
    if self.height != 0 {
      try visitor.visitSingularInt64Field(value: self.height, fieldNumber: 3)
    }
    if let v = self._time {
      try visitor.visitSingularMessageField(value: v, fieldNumber: 4)
    }
    if self.totalVotingPower != 0 {
      try visitor.visitSingularInt64Field(value: self.totalVotingPower, fieldNumber: 5)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_Evidence, rhs: Tendermint_Abci_Evidence) -> Bool {
    if lhs.type != rhs.type {return false}
    if lhs._validator != rhs._validator {return false}
    if lhs.height != rhs.height {return false}
    if lhs._time != rhs._time {return false}
    if lhs.totalVotingPower != rhs.totalVotingPower {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}

extension Tendermint_Abci_Snapshot: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
  static let protoMessageName: String = _protobuf_package + ".Snapshot"
  static let _protobuf_nameMap: SwiftProtobuf._NameMap = [
    1: .same(proto: "height"),
    2: .same(proto: "format"),
    3: .same(proto: "chunks"),
    4: .same(proto: "hash"),
    5: .same(proto: "metadata"),
  ]

  mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
    while let fieldNumber = try decoder.nextFieldNumber() {
      // The use of inline closures is to circumvent an issue where the compiler
      // allocates stack space for every case branch when no optimizations are
      // enabled. https://github.com/apple/swift-protobuf/issues/1034
      switch fieldNumber {
      case 1: try { try decoder.decodeSingularUInt64Field(value: &self.height) }()
      case 2: try { try decoder.decodeSingularUInt32Field(value: &self.format) }()
      case 3: try { try decoder.decodeSingularUInt32Field(value: &self.chunks) }()
      case 4: try { try decoder.decodeSingularBytesField(value: &self.hash) }()
      case 5: try { try decoder.decodeSingularBytesField(value: &self.metadata) }()
      default: break
      }
    }
  }

  func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
    if self.height != 0 {
      try visitor.visitSingularUInt64Field(value: self.height, fieldNumber: 1)
    }
    if self.format != 0 {
      try visitor.visitSingularUInt32Field(value: self.format, fieldNumber: 2)
    }
    if self.chunks != 0 {
      try visitor.visitSingularUInt32Field(value: self.chunks, fieldNumber: 3)
    }
    if !self.hash.isEmpty {
      try visitor.visitSingularBytesField(value: self.hash, fieldNumber: 4)
    }
    if !self.metadata.isEmpty {
      try visitor.visitSingularBytesField(value: self.metadata, fieldNumber: 5)
    }
    try unknownFields.traverse(visitor: &visitor)
  }

  static func ==(lhs: Tendermint_Abci_Snapshot, rhs: Tendermint_Abci_Snapshot) -> Bool {
    if lhs.height != rhs.height {return false}
    if lhs.format != rhs.format {return false}
    if lhs.chunks != rhs.chunks {return false}
    if lhs.hash != rhs.hash {return false}
    if lhs.metadata != rhs.metadata {return false}
    if lhs.unknownFields != rhs.unknownFields {return false}
    return true
  }
}
