{- This file was auto-generated from iavl/api.proto by the proto-lens-protoc program. -}
{-# LANGUAGE ScopedTypeVariables, DataKinds, TypeFamilies,
  UndecidableInstances, GeneralizedNewtypeDeriving,
  MultiParamTypeClasses, FlexibleContexts, FlexibleInstances,
  PatternSynonyms, MagicHash, NoImplicitPrelude, DataKinds,
  BangPatterns, TypeApplications #-}
{-# OPTIONS_GHC -fno-warn-unused-imports#-}
{-# OPTIONS_GHC -fno-warn-duplicate-exports#-}
module Proto.Iavl.Api
       (IAVLService(..), DeleteVersionRequest(), DeleteVersionResponse(),
        GetRequest(), GetResponse(), GetVersionedRequest(),
        GetWithProofResponse(), HasRequest(), HasResponse(),
        HashResponse(), PathToLeaf(), ProofInnerNode(), ProofLeafNode(),
        RangeProof(), RemoveRequest(), RemoveResponse(),
        SaveVersionResponse(), SetRequest(), SetResponse(),
        VerifyAbsenceRequest(), VerifyItemRequest(), VerifyRequest(),
        VersionExistsRequest(), VersionExistsResponse(), VersionResponse())
       where
import qualified Data.ProtoLens.Runtime.Control.DeepSeq
       as Control.DeepSeq
import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Prism
       as Data.ProtoLens.Prism
import qualified Data.ProtoLens.Runtime.Prelude as Prelude
import qualified Data.ProtoLens.Runtime.Data.Int as Data.Int
import qualified Data.ProtoLens.Runtime.Data.Monoid as Data.Monoid
import qualified Data.ProtoLens.Runtime.Data.Word as Data.Word
import qualified Data.ProtoLens.Runtime.Data.ProtoLens
       as Data.ProtoLens
import qualified
       Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Bytes
       as Data.ProtoLens.Encoding.Bytes
import qualified
       Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Growing
       as Data.ProtoLens.Encoding.Growing
import qualified
       Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Parser.Unsafe
       as Data.ProtoLens.Encoding.Parser.Unsafe
import qualified
       Data.ProtoLens.Runtime.Data.ProtoLens.Encoding.Wire
       as Data.ProtoLens.Encoding.Wire
import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Field
       as Data.ProtoLens.Field
import qualified Data.ProtoLens.Runtime.Data.ProtoLens.Message.Enum
       as Data.ProtoLens.Message.Enum
import qualified
       Data.ProtoLens.Runtime.Data.ProtoLens.Service.Types
       as Data.ProtoLens.Service.Types
import qualified Data.ProtoLens.Runtime.Lens.Family2
       as Lens.Family2
import qualified Data.ProtoLens.Runtime.Lens.Family2.Unchecked
       as Lens.Family2.Unchecked
import qualified Data.ProtoLens.Runtime.Data.Text as Data.Text
import qualified Data.ProtoLens.Runtime.Data.Map as Data.Map
import qualified Data.ProtoLens.Runtime.Data.ByteString
       as Data.ByteString
import qualified Data.ProtoLens.Runtime.Data.ByteString.Char8
       as Data.ByteString.Char8
import qualified Data.ProtoLens.Runtime.Data.Text.Encoding
       as Data.Text.Encoding
import qualified Data.ProtoLens.Runtime.Data.Vector as Data.Vector
import qualified Data.ProtoLens.Runtime.Data.Vector.Generic
       as Data.Vector.Generic
import qualified Data.ProtoLens.Runtime.Data.Vector.Unboxed
       as Data.Vector.Unboxed
import qualified Data.ProtoLens.Runtime.Text.Read as Text.Read
import qualified Proto.Google.Api.Annotations
import qualified Proto.Google.Protobuf.Empty

{- | Fields :

    * 'Proto.Iavl.Api_Fields.version' @:: Lens' DeleteVersionRequest Data.Int.Int64@
 -}
data DeleteVersionRequest = DeleteVersionRequest{_DeleteVersionRequest'version
                                                 :: !Data.Int.Int64,
                                                 _DeleteVersionRequest'_unknownFields ::
                                                 !Data.ProtoLens.FieldSet}
                              deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show DeleteVersionRequest where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField DeleteVersionRequest
           "version"
           (Data.Int.Int64)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DeleteVersionRequest'version
               (\ x__ y__ -> x__{_DeleteVersionRequest'version = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message DeleteVersionRequest where
        messageName _ = Data.Text.pack "proto.DeleteVersionRequest"
        fieldsByTag
          = let version__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "version"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"version"))
                      :: Data.ProtoLens.FieldDescriptor DeleteVersionRequest
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, version__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _DeleteVersionRequest'_unknownFields
              (\ x__ y__ -> x__{_DeleteVersionRequest'_unknownFields = y__})
        defMessage
          = DeleteVersionRequest{_DeleteVersionRequest'version =
                                   Data.ProtoLens.fieldDefault,
                                 _DeleteVersionRequest'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     DeleteVersionRequest ->
                       Data.ProtoLens.Encoding.Bytes.Parser DeleteVersionRequest
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                8 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                Data.ProtoLens.Encoding.Bytes.getVarInt)
                                               Data.ProtoLens.Encoding.Bytes.<?> "version"
                                        loop
                                          (Lens.Family2.set (Data.ProtoLens.Field.field @"version")
                                             y
                                             x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "DeleteVersionRequest"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"version") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 8) Data.Monoid.<>
                      ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                         Prelude.fromIntegral)
                        _v)
                 Data.Monoid.<>
                 Data.ProtoLens.Encoding.Wire.buildFieldSet
                   (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData DeleteVersionRequest where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_DeleteVersionRequest'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_DeleteVersionRequest'version x__) (())))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.rootHash' @:: Lens' DeleteVersionResponse Data.ByteString.ByteString@
    * 'Proto.Iavl.Api_Fields.version' @:: Lens' DeleteVersionResponse Data.Int.Int64@
 -}
data DeleteVersionResponse = DeleteVersionResponse{_DeleteVersionResponse'rootHash
                                                   :: !Data.ByteString.ByteString,
                                                   _DeleteVersionResponse'version ::
                                                   !Data.Int.Int64,
                                                   _DeleteVersionResponse'_unknownFields ::
                                                   !Data.ProtoLens.FieldSet}
                               deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show DeleteVersionResponse where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField DeleteVersionResponse
           "rootHash"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DeleteVersionResponse'rootHash
               (\ x__ y__ -> x__{_DeleteVersionResponse'rootHash = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField DeleteVersionResponse
           "version"
           (Data.Int.Int64)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _DeleteVersionResponse'version
               (\ x__ y__ -> x__{_DeleteVersionResponse'version = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message DeleteVersionResponse where
        messageName _ = Data.Text.pack "proto.DeleteVersionResponse"
        fieldsByTag
          = let rootHash__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "root_hash"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"rootHash"))
                      :: Data.ProtoLens.FieldDescriptor DeleteVersionResponse
                version__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "version"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"version"))
                      :: Data.ProtoLens.FieldDescriptor DeleteVersionResponse
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, rootHash__field_descriptor),
                 (Data.ProtoLens.Tag 2, version__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _DeleteVersionResponse'_unknownFields
              (\ x__ y__ -> x__{_DeleteVersionResponse'_unknownFields = y__})
        defMessage
          = DeleteVersionResponse{_DeleteVersionResponse'rootHash =
                                    Data.ProtoLens.fieldDefault,
                                  _DeleteVersionResponse'version = Data.ProtoLens.fieldDefault,
                                  _DeleteVersionResponse'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     DeleteVersionResponse ->
                       Data.ProtoLens.Encoding.Bytes.Parser DeleteVersionResponse
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "root_hash"
                                         loop
                                           (Lens.Family2.set
                                              (Data.ProtoLens.Field.field @"rootHash")
                                              y
                                              x)
                                16 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                 Data.ProtoLens.Encoding.Bytes.getVarInt)
                                                Data.ProtoLens.Encoding.Bytes.<?> "version"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"version")
                                              y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "DeleteVersionResponse"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"rootHash") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 10) Data.Monoid.<>
                      (\ bs ->
                         (Data.ProtoLens.Encoding.Bytes.putVarInt
                            (Prelude.fromIntegral (Data.ByteString.length bs)))
                           Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                        _v)
                 Data.Monoid.<>
                 (let _v
                        = Lens.Family2.view (Data.ProtoLens.Field.field @"version") _x
                    in
                    if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                      Data.Monoid.mempty else
                      (Data.ProtoLens.Encoding.Bytes.putVarInt 16) Data.Monoid.<>
                        ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                           Prelude.fromIntegral)
                          _v)
                   Data.Monoid.<>
                   Data.ProtoLens.Encoding.Wire.buildFieldSet
                     (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData DeleteVersionResponse where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_DeleteVersionResponse'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_DeleteVersionResponse'rootHash x__)
                    (Control.DeepSeq.deepseq (_DeleteVersionResponse'version x__)
                       (()))))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.key' @:: Lens' GetRequest Data.ByteString.ByteString@
 -}
data GetRequest = GetRequest{_GetRequest'key ::
                             !Data.ByteString.ByteString,
                             _GetRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
                    deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show GetRequest where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField GetRequest "key"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _GetRequest'key
               (\ x__ y__ -> x__{_GetRequest'key = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message GetRequest where
        messageName _ = Data.Text.pack "proto.GetRequest"
        fieldsByTag
          = let key__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "key"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"key"))
                      :: Data.ProtoLens.FieldDescriptor GetRequest
              in
              Data.Map.fromList [(Data.ProtoLens.Tag 1, key__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _GetRequest'_unknownFields
              (\ x__ y__ -> x__{_GetRequest'_unknownFields = y__})
        defMessage
          = GetRequest{_GetRequest'key = Data.ProtoLens.fieldDefault,
                       _GetRequest'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     GetRequest -> Data.ProtoLens.Encoding.Bytes.Parser GetRequest
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "key"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"key") y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "GetRequest"
        buildMessage
          = (\ _x ->
               (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"key") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 10) Data.Monoid.<>
                      (\ bs ->
                         (Data.ProtoLens.Encoding.Bytes.putVarInt
                            (Prelude.fromIntegral (Data.ByteString.length bs)))
                           Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                        _v)
                 Data.Monoid.<>
                 Data.ProtoLens.Encoding.Wire.buildFieldSet
                   (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData GetRequest where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_GetRequest'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_GetRequest'key x__) (())))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.index' @:: Lens' GetResponse Data.Int.Int64@
    * 'Proto.Iavl.Api_Fields.value' @:: Lens' GetResponse Data.ByteString.ByteString@
 -}
data GetResponse = GetResponse{_GetResponse'index ::
                               !Data.Int.Int64,
                               _GetResponse'value :: !Data.ByteString.ByteString,
                               _GetResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
                     deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show GetResponse where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField GetResponse "index"
           (Data.Int.Int64)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _GetResponse'index
               (\ x__ y__ -> x__{_GetResponse'index = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField GetResponse "value"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _GetResponse'value
               (\ x__ y__ -> x__{_GetResponse'value = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message GetResponse where
        messageName _ = Data.Text.pack "proto.GetResponse"
        fieldsByTag
          = let index__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "index"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"index"))
                      :: Data.ProtoLens.FieldDescriptor GetResponse
                value__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "value"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"value"))
                      :: Data.ProtoLens.FieldDescriptor GetResponse
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, index__field_descriptor),
                 (Data.ProtoLens.Tag 2, value__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _GetResponse'_unknownFields
              (\ x__ y__ -> x__{_GetResponse'_unknownFields = y__})
        defMessage
          = GetResponse{_GetResponse'index = Data.ProtoLens.fieldDefault,
                        _GetResponse'value = Data.ProtoLens.fieldDefault,
                        _GetResponse'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     GetResponse -> Data.ProtoLens.Encoding.Bytes.Parser GetResponse
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                8 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                Data.ProtoLens.Encoding.Bytes.getVarInt)
                                               Data.ProtoLens.Encoding.Bytes.<?> "index"
                                        loop
                                          (Lens.Family2.set (Data.ProtoLens.Field.field @"index") y
                                             x)
                                18 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "value"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"value") y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "GetResponse"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"index") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 8) Data.Monoid.<>
                      ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                         Prelude.fromIntegral)
                        _v)
                 Data.Monoid.<>
                 (let _v
                        = Lens.Family2.view (Data.ProtoLens.Field.field @"value") _x
                    in
                    if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                      Data.Monoid.mempty else
                      (Data.ProtoLens.Encoding.Bytes.putVarInt 18) Data.Monoid.<>
                        (\ bs ->
                           (Data.ProtoLens.Encoding.Bytes.putVarInt
                              (Prelude.fromIntegral (Data.ByteString.length bs)))
                             Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                          _v)
                   Data.Monoid.<>
                   Data.ProtoLens.Encoding.Wire.buildFieldSet
                     (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData GetResponse where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_GetResponse'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_GetResponse'index x__)
                    (Control.DeepSeq.deepseq (_GetResponse'value x__) (()))))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.version' @:: Lens' GetVersionedRequest Data.Int.Int64@
    * 'Proto.Iavl.Api_Fields.key' @:: Lens' GetVersionedRequest Data.ByteString.ByteString@
 -}
data GetVersionedRequest = GetVersionedRequest{_GetVersionedRequest'version
                                               :: !Data.Int.Int64,
                                               _GetVersionedRequest'key ::
                                               !Data.ByteString.ByteString,
                                               _GetVersionedRequest'_unknownFields ::
                                               !Data.ProtoLens.FieldSet}
                             deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show GetVersionedRequest where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField GetVersionedRequest
           "version"
           (Data.Int.Int64)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _GetVersionedRequest'version
               (\ x__ y__ -> x__{_GetVersionedRequest'version = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField GetVersionedRequest "key"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _GetVersionedRequest'key
               (\ x__ y__ -> x__{_GetVersionedRequest'key = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message GetVersionedRequest where
        messageName _ = Data.Text.pack "proto.GetVersionedRequest"
        fieldsByTag
          = let version__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "version"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"version"))
                      :: Data.ProtoLens.FieldDescriptor GetVersionedRequest
                key__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "key"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"key"))
                      :: Data.ProtoLens.FieldDescriptor GetVersionedRequest
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, version__field_descriptor),
                 (Data.ProtoLens.Tag 2, key__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _GetVersionedRequest'_unknownFields
              (\ x__ y__ -> x__{_GetVersionedRequest'_unknownFields = y__})
        defMessage
          = GetVersionedRequest{_GetVersionedRequest'version =
                                  Data.ProtoLens.fieldDefault,
                                _GetVersionedRequest'key = Data.ProtoLens.fieldDefault,
                                _GetVersionedRequest'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     GetVersionedRequest ->
                       Data.ProtoLens.Encoding.Bytes.Parser GetVersionedRequest
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                8 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                Data.ProtoLens.Encoding.Bytes.getVarInt)
                                               Data.ProtoLens.Encoding.Bytes.<?> "version"
                                        loop
                                          (Lens.Family2.set (Data.ProtoLens.Field.field @"version")
                                             y
                                             x)
                                18 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "key"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"key") y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "GetVersionedRequest"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"version") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 8) Data.Monoid.<>
                      ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                         Prelude.fromIntegral)
                        _v)
                 Data.Monoid.<>
                 (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"key") _x
                    in
                    if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                      Data.Monoid.mempty else
                      (Data.ProtoLens.Encoding.Bytes.putVarInt 18) Data.Monoid.<>
                        (\ bs ->
                           (Data.ProtoLens.Encoding.Bytes.putVarInt
                              (Prelude.fromIntegral (Data.ByteString.length bs)))
                             Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                          _v)
                   Data.Monoid.<>
                   Data.ProtoLens.Encoding.Wire.buildFieldSet
                     (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData GetVersionedRequest where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_GetVersionedRequest'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_GetVersionedRequest'version x__)
                    (Control.DeepSeq.deepseq (_GetVersionedRequest'key x__) (()))))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.value' @:: Lens' GetWithProofResponse Data.ByteString.ByteString@
    * 'Proto.Iavl.Api_Fields.proof' @:: Lens' GetWithProofResponse RangeProof@
    * 'Proto.Iavl.Api_Fields.maybe'proof' @:: Lens' GetWithProofResponse (Prelude.Maybe RangeProof)@
 -}
data GetWithProofResponse = GetWithProofResponse{_GetWithProofResponse'value
                                                 :: !Data.ByteString.ByteString,
                                                 _GetWithProofResponse'proof ::
                                                 !(Prelude.Maybe RangeProof),
                                                 _GetWithProofResponse'_unknownFields ::
                                                 !Data.ProtoLens.FieldSet}
                              deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show GetWithProofResponse where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField GetWithProofResponse "value"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _GetWithProofResponse'value
               (\ x__ y__ -> x__{_GetWithProofResponse'value = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField GetWithProofResponse "proof"
           (RangeProof)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _GetWithProofResponse'proof
               (\ x__ y__ -> x__{_GetWithProofResponse'proof = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.defMessage
instance Data.ProtoLens.Field.HasField GetWithProofResponse
           "maybe'proof"
           (Prelude.Maybe RangeProof)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _GetWithProofResponse'proof
               (\ x__ y__ -> x__{_GetWithProofResponse'proof = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message GetWithProofResponse where
        messageName _ = Data.Text.pack "proto.GetWithProofResponse"
        fieldsByTag
          = let value__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "value"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"value"))
                      :: Data.ProtoLens.FieldDescriptor GetWithProofResponse
                proof__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "proof"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor RangeProof)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'proof"))
                      :: Data.ProtoLens.FieldDescriptor GetWithProofResponse
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, value__field_descriptor),
                 (Data.ProtoLens.Tag 2, proof__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _GetWithProofResponse'_unknownFields
              (\ x__ y__ -> x__{_GetWithProofResponse'_unknownFields = y__})
        defMessage
          = GetWithProofResponse{_GetWithProofResponse'value =
                                   Data.ProtoLens.fieldDefault,
                                 _GetWithProofResponse'proof = Prelude.Nothing,
                                 _GetWithProofResponse'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     GetWithProofResponse ->
                       Data.ProtoLens.Encoding.Bytes.Parser GetWithProofResponse
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "value"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"value") y
                                              x)
                                18 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.isolate
                                                    (Prelude.fromIntegral len)
                                                    Data.ProtoLens.parseMessage)
                                                Data.ProtoLens.Encoding.Bytes.<?> "proof"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"proof") y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "GetWithProofResponse"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"value") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 10) Data.Monoid.<>
                      (\ bs ->
                         (Data.ProtoLens.Encoding.Bytes.putVarInt
                            (Prelude.fromIntegral (Data.ByteString.length bs)))
                           Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                        _v)
                 Data.Monoid.<>
                 (case
                    Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'proof") _x of
                      (Prelude.Nothing) -> Data.Monoid.mempty
                      Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
                                           Data.Monoid.<>
                                           (((\ bs ->
                                                (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                   (Prelude.fromIntegral
                                                      (Data.ByteString.length bs)))
                                                  Data.Monoid.<>
                                                  Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                              Prelude.. Data.ProtoLens.encodeMessage)
                                             _v)
                   Data.Monoid.<>
                   Data.ProtoLens.Encoding.Wire.buildFieldSet
                     (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData GetWithProofResponse where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_GetWithProofResponse'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_GetWithProofResponse'value x__)
                    (Control.DeepSeq.deepseq (_GetWithProofResponse'proof x__) (()))))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.version' @:: Lens' HasRequest Data.Int.Int64@
    * 'Proto.Iavl.Api_Fields.key' @:: Lens' HasRequest Data.ByteString.ByteString@
 -}
data HasRequest = HasRequest{_HasRequest'version ::
                             !Data.Int.Int64,
                             _HasRequest'key :: !Data.ByteString.ByteString,
                             _HasRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
                    deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show HasRequest where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField HasRequest "version"
           (Data.Int.Int64)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _HasRequest'version
               (\ x__ y__ -> x__{_HasRequest'version = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField HasRequest "key"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _HasRequest'key
               (\ x__ y__ -> x__{_HasRequest'key = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message HasRequest where
        messageName _ = Data.Text.pack "proto.HasRequest"
        fieldsByTag
          = let version__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "version"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"version"))
                      :: Data.ProtoLens.FieldDescriptor HasRequest
                key__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "key"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"key"))
                      :: Data.ProtoLens.FieldDescriptor HasRequest
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, version__field_descriptor),
                 (Data.ProtoLens.Tag 2, key__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _HasRequest'_unknownFields
              (\ x__ y__ -> x__{_HasRequest'_unknownFields = y__})
        defMessage
          = HasRequest{_HasRequest'version = Data.ProtoLens.fieldDefault,
                       _HasRequest'key = Data.ProtoLens.fieldDefault,
                       _HasRequest'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     HasRequest -> Data.ProtoLens.Encoding.Bytes.Parser HasRequest
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                8 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                Data.ProtoLens.Encoding.Bytes.getVarInt)
                                               Data.ProtoLens.Encoding.Bytes.<?> "version"
                                        loop
                                          (Lens.Family2.set (Data.ProtoLens.Field.field @"version")
                                             y
                                             x)
                                18 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "key"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"key") y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "HasRequest"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"version") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 8) Data.Monoid.<>
                      ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                         Prelude.fromIntegral)
                        _v)
                 Data.Monoid.<>
                 (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"key") _x
                    in
                    if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                      Data.Monoid.mempty else
                      (Data.ProtoLens.Encoding.Bytes.putVarInt 18) Data.Monoid.<>
                        (\ bs ->
                           (Data.ProtoLens.Encoding.Bytes.putVarInt
                              (Prelude.fromIntegral (Data.ByteString.length bs)))
                             Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                          _v)
                   Data.Monoid.<>
                   Data.ProtoLens.Encoding.Wire.buildFieldSet
                     (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData HasRequest where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_HasRequest'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_HasRequest'version x__)
                    (Control.DeepSeq.deepseq (_HasRequest'key x__) (()))))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.result' @:: Lens' HasResponse Prelude.Bool@
 -}
data HasResponse = HasResponse{_HasResponse'result ::
                               !Prelude.Bool,
                               _HasResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
                     deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show HasResponse where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField HasResponse "result"
           (Prelude.Bool)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _HasResponse'result
               (\ x__ y__ -> x__{_HasResponse'result = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message HasResponse where
        messageName _ = Data.Text.pack "proto.HasResponse"
        fieldsByTag
          = let result__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "result"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"result"))
                      :: Data.ProtoLens.FieldDescriptor HasResponse
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, result__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _HasResponse'_unknownFields
              (\ x__ y__ -> x__{_HasResponse'_unknownFields = y__})
        defMessage
          = HasResponse{_HasResponse'result = Data.ProtoLens.fieldDefault,
                        _HasResponse'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     HasResponse -> Data.ProtoLens.Encoding.Bytes.Parser HasResponse
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                8 -> do y <- (Prelude.fmap ((Prelude./=) 0)
                                                Data.ProtoLens.Encoding.Bytes.getVarInt)
                                               Data.ProtoLens.Encoding.Bytes.<?> "result"
                                        loop
                                          (Lens.Family2.set (Data.ProtoLens.Field.field @"result") y
                                             x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "HasResponse"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"result") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 8) Data.Monoid.<>
                      ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                         (\ b -> if b then 1 else 0))
                        _v)
                 Data.Monoid.<>
                 Data.ProtoLens.Encoding.Wire.buildFieldSet
                   (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData HasResponse where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_HasResponse'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_HasResponse'result x__) (())))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.rootHash' @:: Lens' HashResponse Data.ByteString.ByteString@
 -}
data HashResponse = HashResponse{_HashResponse'rootHash ::
                                 !Data.ByteString.ByteString,
                                 _HashResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
                      deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show HashResponse where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField HashResponse "rootHash"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _HashResponse'rootHash
               (\ x__ y__ -> x__{_HashResponse'rootHash = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message HashResponse where
        messageName _ = Data.Text.pack "proto.HashResponse"
        fieldsByTag
          = let rootHash__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "root_hash"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"rootHash"))
                      :: Data.ProtoLens.FieldDescriptor HashResponse
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, rootHash__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _HashResponse'_unknownFields
              (\ x__ y__ -> x__{_HashResponse'_unknownFields = y__})
        defMessage
          = HashResponse{_HashResponse'rootHash =
                           Data.ProtoLens.fieldDefault,
                         _HashResponse'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     HashResponse -> Data.ProtoLens.Encoding.Bytes.Parser HashResponse
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "root_hash"
                                         loop
                                           (Lens.Family2.set
                                              (Data.ProtoLens.Field.field @"rootHash")
                                              y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "HashResponse"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"rootHash") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 10) Data.Monoid.<>
                      (\ bs ->
                         (Data.ProtoLens.Encoding.Bytes.putVarInt
                            (Prelude.fromIntegral (Data.ByteString.length bs)))
                           Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                        _v)
                 Data.Monoid.<>
                 Data.ProtoLens.Encoding.Wire.buildFieldSet
                   (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData HashResponse where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_HashResponse'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_HashResponse'rootHash x__) (())))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.nodes' @:: Lens' PathToLeaf [ProofInnerNode]@
    * 'Proto.Iavl.Api_Fields.vec'nodes' @:: Lens' PathToLeaf (Data.Vector.Vector ProofInnerNode)@
 -}
data PathToLeaf = PathToLeaf{_PathToLeaf'nodes ::
                             !(Data.Vector.Vector ProofInnerNode),
                             _PathToLeaf'_unknownFields :: !Data.ProtoLens.FieldSet}
                    deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show PathToLeaf where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField PathToLeaf "nodes"
           ([ProofInnerNode])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _PathToLeaf'nodes
               (\ x__ y__ -> x__{_PathToLeaf'nodes = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField PathToLeaf "vec'nodes"
           (Data.Vector.Vector ProofInnerNode)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _PathToLeaf'nodes
               (\ x__ y__ -> x__{_PathToLeaf'nodes = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message PathToLeaf where
        messageName _ = Data.Text.pack "proto.PathToLeaf"
        fieldsByTag
          = let nodes__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "nodes"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor ProofInnerNode)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"nodes"))
                      :: Data.ProtoLens.FieldDescriptor PathToLeaf
              in
              Data.Map.fromList [(Data.ProtoLens.Tag 1, nodes__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _PathToLeaf'_unknownFields
              (\ x__ y__ -> x__{_PathToLeaf'_unknownFields = y__})
        defMessage
          = PathToLeaf{_PathToLeaf'nodes = Data.Vector.Generic.empty,
                       _PathToLeaf'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     PathToLeaf ->
                       Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                         Data.ProtoLens.Encoding.Growing.RealWorld
                         ProofInnerNode
                         -> Data.ProtoLens.Encoding.Bytes.Parser PathToLeaf
                loop x mutable'nodes
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do frozen'nodes <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                              (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                 mutable'nodes)
                            let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 (Lens.Family2.set (Data.ProtoLens.Field.field @"vec'nodes")
                                    frozen'nodes
                                    x))
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do !y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                   Data.ProtoLens.Encoding.Bytes.isolate
                                                     (Prelude.fromIntegral len)
                                                     Data.ProtoLens.parseMessage)
                                                 Data.ProtoLens.Encoding.Bytes.<?> "nodes"
                                         v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                (Data.ProtoLens.Encoding.Growing.append
                                                   mutable'nodes
                                                   y)
                                         loop x v
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
                                             mutable'nodes
              in
              (do mutable'nodes <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                     Data.ProtoLens.Encoding.Growing.new
                  loop Data.ProtoLens.defMessage mutable'nodes)
                Data.ProtoLens.Encoding.Bytes.<?> "PathToLeaf"
        buildMessage
          = (\ _x ->
               (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                  (\ _v ->
                     (Data.ProtoLens.Encoding.Bytes.putVarInt 10) Data.Monoid.<>
                       (((\ bs ->
                            (Data.ProtoLens.Encoding.Bytes.putVarInt
                               (Prelude.fromIntegral (Data.ByteString.length bs)))
                              Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs))
                          Prelude.. Data.ProtoLens.encodeMessage)
                         _v)
                  (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'nodes") _x))
                 Data.Monoid.<>
                 Data.ProtoLens.Encoding.Wire.buildFieldSet
                   (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData PathToLeaf where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_PathToLeaf'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_PathToLeaf'nodes x__) (())))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.height' @:: Lens' ProofInnerNode Data.Int.Int32@
    * 'Proto.Iavl.Api_Fields.size' @:: Lens' ProofInnerNode Data.Int.Int64@
    * 'Proto.Iavl.Api_Fields.version' @:: Lens' ProofInnerNode Data.Int.Int64@
    * 'Proto.Iavl.Api_Fields.left' @:: Lens' ProofInnerNode Data.ByteString.ByteString@
    * 'Proto.Iavl.Api_Fields.right' @:: Lens' ProofInnerNode Data.ByteString.ByteString@
 -}
data ProofInnerNode = ProofInnerNode{_ProofInnerNode'height ::
                                     !Data.Int.Int32,
                                     _ProofInnerNode'size :: !Data.Int.Int64,
                                     _ProofInnerNode'version :: !Data.Int.Int64,
                                     _ProofInnerNode'left :: !Data.ByteString.ByteString,
                                     _ProofInnerNode'right :: !Data.ByteString.ByteString,
                                     _ProofInnerNode'_unknownFields :: !Data.ProtoLens.FieldSet}
                        deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show ProofInnerNode where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField ProofInnerNode "height"
           (Data.Int.Int32)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _ProofInnerNode'height
               (\ x__ y__ -> x__{_ProofInnerNode'height = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField ProofInnerNode "size"
           (Data.Int.Int64)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _ProofInnerNode'size
               (\ x__ y__ -> x__{_ProofInnerNode'size = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField ProofInnerNode "version"
           (Data.Int.Int64)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _ProofInnerNode'version
               (\ x__ y__ -> x__{_ProofInnerNode'version = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField ProofInnerNode "left"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _ProofInnerNode'left
               (\ x__ y__ -> x__{_ProofInnerNode'left = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField ProofInnerNode "right"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _ProofInnerNode'right
               (\ x__ y__ -> x__{_ProofInnerNode'right = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message ProofInnerNode where
        messageName _ = Data.Text.pack "proto.ProofInnerNode"
        fieldsByTag
          = let height__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "height"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int32Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int32)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"height"))
                      :: Data.ProtoLens.FieldDescriptor ProofInnerNode
                size__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "size"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"size"))
                      :: Data.ProtoLens.FieldDescriptor ProofInnerNode
                version__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "version"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"version"))
                      :: Data.ProtoLens.FieldDescriptor ProofInnerNode
                left__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "left"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"left"))
                      :: Data.ProtoLens.FieldDescriptor ProofInnerNode
                right__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "right"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"right"))
                      :: Data.ProtoLens.FieldDescriptor ProofInnerNode
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, height__field_descriptor),
                 (Data.ProtoLens.Tag 2, size__field_descriptor),
                 (Data.ProtoLens.Tag 3, version__field_descriptor),
                 (Data.ProtoLens.Tag 4, left__field_descriptor),
                 (Data.ProtoLens.Tag 5, right__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _ProofInnerNode'_unknownFields
              (\ x__ y__ -> x__{_ProofInnerNode'_unknownFields = y__})
        defMessage
          = ProofInnerNode{_ProofInnerNode'height =
                             Data.ProtoLens.fieldDefault,
                           _ProofInnerNode'size = Data.ProtoLens.fieldDefault,
                           _ProofInnerNode'version = Data.ProtoLens.fieldDefault,
                           _ProofInnerNode'left = Data.ProtoLens.fieldDefault,
                           _ProofInnerNode'right = Data.ProtoLens.fieldDefault,
                           _ProofInnerNode'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     ProofInnerNode ->
                       Data.ProtoLens.Encoding.Bytes.Parser ProofInnerNode
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                8 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                Data.ProtoLens.Encoding.Bytes.getVarInt)
                                               Data.ProtoLens.Encoding.Bytes.<?> "height"
                                        loop
                                          (Lens.Family2.set (Data.ProtoLens.Field.field @"height") y
                                             x)
                                16 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                 Data.ProtoLens.Encoding.Bytes.getVarInt)
                                                Data.ProtoLens.Encoding.Bytes.<?> "size"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"size") y
                                              x)
                                24 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                 Data.ProtoLens.Encoding.Bytes.getVarInt)
                                                Data.ProtoLens.Encoding.Bytes.<?> "version"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"version")
                                              y
                                              x)
                                34 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "left"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"left") y
                                              x)
                                42 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "right"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"right") y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "ProofInnerNode"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"height") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 8) Data.Monoid.<>
                      ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                         Prelude.fromIntegral)
                        _v)
                 Data.Monoid.<>
                 (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"size") _x
                    in
                    if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                      Data.Monoid.mempty else
                      (Data.ProtoLens.Encoding.Bytes.putVarInt 16) Data.Monoid.<>
                        ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                           Prelude.fromIntegral)
                          _v)
                   Data.Monoid.<>
                   (let _v
                          = Lens.Family2.view (Data.ProtoLens.Field.field @"version") _x
                      in
                      if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                        Data.Monoid.mempty else
                        (Data.ProtoLens.Encoding.Bytes.putVarInt 24) Data.Monoid.<>
                          ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                             Prelude.fromIntegral)
                            _v)
                     Data.Monoid.<>
                     (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"left") _x
                        in
                        if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                          Data.Monoid.mempty else
                          (Data.ProtoLens.Encoding.Bytes.putVarInt 34) Data.Monoid.<>
                            (\ bs ->
                               (Data.ProtoLens.Encoding.Bytes.putVarInt
                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
                                 Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                              _v)
                       Data.Monoid.<>
                       (let _v
                              = Lens.Family2.view (Data.ProtoLens.Field.field @"right") _x
                          in
                          if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                            Data.Monoid.mempty else
                            (Data.ProtoLens.Encoding.Bytes.putVarInt 42) Data.Monoid.<>
                              (\ bs ->
                                 (Data.ProtoLens.Encoding.Bytes.putVarInt
                                    (Prelude.fromIntegral (Data.ByteString.length bs)))
                                   Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                                _v)
                         Data.Monoid.<>
                         Data.ProtoLens.Encoding.Wire.buildFieldSet
                           (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData ProofInnerNode where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_ProofInnerNode'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_ProofInnerNode'height x__)
                    (Control.DeepSeq.deepseq (_ProofInnerNode'size x__)
                       (Control.DeepSeq.deepseq (_ProofInnerNode'version x__)
                          (Control.DeepSeq.deepseq (_ProofInnerNode'left x__)
                             (Control.DeepSeq.deepseq (_ProofInnerNode'right x__) (())))))))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.key' @:: Lens' ProofLeafNode Data.ByteString.ByteString@
    * 'Proto.Iavl.Api_Fields.valueHash' @:: Lens' ProofLeafNode Data.ByteString.ByteString@
    * 'Proto.Iavl.Api_Fields.version' @:: Lens' ProofLeafNode Data.Int.Int64@
 -}
data ProofLeafNode = ProofLeafNode{_ProofLeafNode'key ::
                                   !Data.ByteString.ByteString,
                                   _ProofLeafNode'valueHash :: !Data.ByteString.ByteString,
                                   _ProofLeafNode'version :: !Data.Int.Int64,
                                   _ProofLeafNode'_unknownFields :: !Data.ProtoLens.FieldSet}
                       deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show ProofLeafNode where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField ProofLeafNode "key"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _ProofLeafNode'key
               (\ x__ y__ -> x__{_ProofLeafNode'key = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField ProofLeafNode "valueHash"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _ProofLeafNode'valueHash
               (\ x__ y__ -> x__{_ProofLeafNode'valueHash = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField ProofLeafNode "version"
           (Data.Int.Int64)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _ProofLeafNode'version
               (\ x__ y__ -> x__{_ProofLeafNode'version = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message ProofLeafNode where
        messageName _ = Data.Text.pack "proto.ProofLeafNode"
        fieldsByTag
          = let key__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "key"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"key"))
                      :: Data.ProtoLens.FieldDescriptor ProofLeafNode
                valueHash__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "value_hash"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"valueHash"))
                      :: Data.ProtoLens.FieldDescriptor ProofLeafNode
                version__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "version"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"version"))
                      :: Data.ProtoLens.FieldDescriptor ProofLeafNode
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, key__field_descriptor),
                 (Data.ProtoLens.Tag 2, valueHash__field_descriptor),
                 (Data.ProtoLens.Tag 3, version__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _ProofLeafNode'_unknownFields
              (\ x__ y__ -> x__{_ProofLeafNode'_unknownFields = y__})
        defMessage
          = ProofLeafNode{_ProofLeafNode'key = Data.ProtoLens.fieldDefault,
                          _ProofLeafNode'valueHash = Data.ProtoLens.fieldDefault,
                          _ProofLeafNode'version = Data.ProtoLens.fieldDefault,
                          _ProofLeafNode'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     ProofLeafNode -> Data.ProtoLens.Encoding.Bytes.Parser ProofLeafNode
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "key"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"key") y
                                              x)
                                18 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "value_hash"
                                         loop
                                           (Lens.Family2.set
                                              (Data.ProtoLens.Field.field @"valueHash")
                                              y
                                              x)
                                24 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                 Data.ProtoLens.Encoding.Bytes.getVarInt)
                                                Data.ProtoLens.Encoding.Bytes.<?> "version"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"version")
                                              y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "ProofLeafNode"
        buildMessage
          = (\ _x ->
               (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"key") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 10) Data.Monoid.<>
                      (\ bs ->
                         (Data.ProtoLens.Encoding.Bytes.putVarInt
                            (Prelude.fromIntegral (Data.ByteString.length bs)))
                           Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                        _v)
                 Data.Monoid.<>
                 (let _v
                        = Lens.Family2.view (Data.ProtoLens.Field.field @"valueHash") _x
                    in
                    if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                      Data.Monoid.mempty else
                      (Data.ProtoLens.Encoding.Bytes.putVarInt 18) Data.Monoid.<>
                        (\ bs ->
                           (Data.ProtoLens.Encoding.Bytes.putVarInt
                              (Prelude.fromIntegral (Data.ByteString.length bs)))
                             Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                          _v)
                   Data.Monoid.<>
                   (let _v
                          = Lens.Family2.view (Data.ProtoLens.Field.field @"version") _x
                      in
                      if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                        Data.Monoid.mempty else
                        (Data.ProtoLens.Encoding.Bytes.putVarInt 24) Data.Monoid.<>
                          ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                             Prelude.fromIntegral)
                            _v)
                     Data.Monoid.<>
                     Data.ProtoLens.Encoding.Wire.buildFieldSet
                       (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData ProofLeafNode where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_ProofLeafNode'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_ProofLeafNode'key x__)
                    (Control.DeepSeq.deepseq (_ProofLeafNode'valueHash x__)
                       (Control.DeepSeq.deepseq (_ProofLeafNode'version x__) (())))))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.key' @:: Lens' RangeProof Data.ByteString.ByteString@
    * 'Proto.Iavl.Api_Fields.leftPath' @:: Lens' RangeProof PathToLeaf@
    * 'Proto.Iavl.Api_Fields.maybe'leftPath' @:: Lens' RangeProof (Prelude.Maybe PathToLeaf)@
    * 'Proto.Iavl.Api_Fields.innerNodes' @:: Lens' RangeProof [PathToLeaf]@
    * 'Proto.Iavl.Api_Fields.vec'innerNodes' @:: Lens' RangeProof (Data.Vector.Vector PathToLeaf)@
    * 'Proto.Iavl.Api_Fields.leaves' @:: Lens' RangeProof [ProofLeafNode]@
    * 'Proto.Iavl.Api_Fields.vec'leaves' @:: Lens' RangeProof (Data.Vector.Vector ProofLeafNode)@
 -}
data RangeProof = RangeProof{_RangeProof'key ::
                             !Data.ByteString.ByteString,
                             _RangeProof'leftPath :: !(Prelude.Maybe PathToLeaf),
                             _RangeProof'innerNodes :: !(Data.Vector.Vector PathToLeaf),
                             _RangeProof'leaves :: !(Data.Vector.Vector ProofLeafNode),
                             _RangeProof'_unknownFields :: !Data.ProtoLens.FieldSet}
                    deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show RangeProof where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField RangeProof "key"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _RangeProof'key
               (\ x__ y__ -> x__{_RangeProof'key = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField RangeProof "leftPath"
           (PathToLeaf)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _RangeProof'leftPath
               (\ x__ y__ -> x__{_RangeProof'leftPath = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.defMessage
instance Data.ProtoLens.Field.HasField RangeProof "maybe'leftPath"
           (Prelude.Maybe PathToLeaf)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _RangeProof'leftPath
               (\ x__ y__ -> x__{_RangeProof'leftPath = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField RangeProof "innerNodes"
           ([PathToLeaf])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _RangeProof'innerNodes
               (\ x__ y__ -> x__{_RangeProof'innerNodes = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField RangeProof "vec'innerNodes"
           (Data.Vector.Vector PathToLeaf)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _RangeProof'innerNodes
               (\ x__ y__ -> x__{_RangeProof'innerNodes = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField RangeProof "leaves"
           ([ProofLeafNode])
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _RangeProof'leaves
               (\ x__ y__ -> x__{_RangeProof'leaves = y__}))
              Prelude..
              Lens.Family2.Unchecked.lens Data.Vector.Generic.toList
                (\ _ y__ -> Data.Vector.Generic.fromList y__)
instance Data.ProtoLens.Field.HasField RangeProof "vec'leaves"
           (Data.Vector.Vector ProofLeafNode)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _RangeProof'leaves
               (\ x__ y__ -> x__{_RangeProof'leaves = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message RangeProof where
        messageName _ = Data.Text.pack "proto.RangeProof"
        fieldsByTag
          = let key__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "key"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"key"))
                      :: Data.ProtoLens.FieldDescriptor RangeProof
                leftPath__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "left_path"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor PathToLeaf)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'leftPath"))
                      :: Data.ProtoLens.FieldDescriptor RangeProof
                innerNodes__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "inner_nodes"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor PathToLeaf)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"innerNodes"))
                      :: Data.ProtoLens.FieldDescriptor RangeProof
                leaves__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "leaves"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor ProofLeafNode)
                      (Data.ProtoLens.RepeatedField Data.ProtoLens.Unpacked
                         (Data.ProtoLens.Field.field @"leaves"))
                      :: Data.ProtoLens.FieldDescriptor RangeProof
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, key__field_descriptor),
                 (Data.ProtoLens.Tag 2, leftPath__field_descriptor),
                 (Data.ProtoLens.Tag 3, innerNodes__field_descriptor),
                 (Data.ProtoLens.Tag 4, leaves__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _RangeProof'_unknownFields
              (\ x__ y__ -> x__{_RangeProof'_unknownFields = y__})
        defMessage
          = RangeProof{_RangeProof'key = Data.ProtoLens.fieldDefault,
                       _RangeProof'leftPath = Prelude.Nothing,
                       _RangeProof'innerNodes = Data.Vector.Generic.empty,
                       _RangeProof'leaves = Data.Vector.Generic.empty,
                       _RangeProof'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     RangeProof ->
                       Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                         Data.ProtoLens.Encoding.Growing.RealWorld
                         PathToLeaf
                         ->
                         Data.ProtoLens.Encoding.Growing.Growing Data.Vector.Vector
                           Data.ProtoLens.Encoding.Growing.RealWorld
                           ProofLeafNode
                           -> Data.ProtoLens.Encoding.Bytes.Parser RangeProof
                loop x mutable'innerNodes mutable'leaves
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do frozen'innerNodes <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                   (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                      mutable'innerNodes)
                            frozen'leaves <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                               (Data.ProtoLens.Encoding.Growing.unsafeFreeze
                                                  mutable'leaves)
                            let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 (Lens.Family2.set (Data.ProtoLens.Field.field @"vec'innerNodes")
                                    frozen'innerNodes
                                    (Lens.Family2.set (Data.ProtoLens.Field.field @"vec'leaves")
                                       frozen'leaves
                                       x)))
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "key"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"key") y
                                              x)
                                           mutable'innerNodes
                                           mutable'leaves
                                18 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.isolate
                                                    (Prelude.fromIntegral len)
                                                    Data.ProtoLens.parseMessage)
                                                Data.ProtoLens.Encoding.Bytes.<?> "left_path"
                                         loop
                                           (Lens.Family2.set
                                              (Data.ProtoLens.Field.field @"leftPath")
                                              y
                                              x)
                                           mutable'innerNodes
                                           mutable'leaves
                                26 -> do !y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                   Data.ProtoLens.Encoding.Bytes.isolate
                                                     (Prelude.fromIntegral len)
                                                     Data.ProtoLens.parseMessage)
                                                 Data.ProtoLens.Encoding.Bytes.<?> "inner_nodes"
                                         v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                (Data.ProtoLens.Encoding.Growing.append
                                                   mutable'innerNodes
                                                   y)
                                         loop x v mutable'leaves
                                34 -> do !y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                   Data.ProtoLens.Encoding.Bytes.isolate
                                                     (Prelude.fromIntegral len)
                                                     Data.ProtoLens.parseMessage)
                                                 Data.ProtoLens.Encoding.Bytes.<?> "leaves"
                                         v <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                                (Data.ProtoLens.Encoding.Growing.append
                                                   mutable'leaves
                                                   y)
                                         loop x mutable'innerNodes v
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
                                             mutable'innerNodes
                                             mutable'leaves
              in
              (do mutable'innerNodes <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                          Data.ProtoLens.Encoding.Growing.new
                  mutable'leaves <- Data.ProtoLens.Encoding.Parser.Unsafe.unsafeLiftIO
                                      Data.ProtoLens.Encoding.Growing.new
                  loop Data.ProtoLens.defMessage mutable'innerNodes mutable'leaves)
                Data.ProtoLens.Encoding.Bytes.<?> "RangeProof"
        buildMessage
          = (\ _x ->
               (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"key") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 10) Data.Monoid.<>
                      (\ bs ->
                         (Data.ProtoLens.Encoding.Bytes.putVarInt
                            (Prelude.fromIntegral (Data.ByteString.length bs)))
                           Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                        _v)
                 Data.Monoid.<>
                 (case
                    Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'leftPath") _x
                    of
                      (Prelude.Nothing) -> Data.Monoid.mempty
                      Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
                                           Data.Monoid.<>
                                           (((\ bs ->
                                                (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                   (Prelude.fromIntegral
                                                      (Data.ByteString.length bs)))
                                                  Data.Monoid.<>
                                                  Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                              Prelude.. Data.ProtoLens.encodeMessage)
                                             _v)
                   Data.Monoid.<>
                   (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                      (\ _v ->
                         (Data.ProtoLens.Encoding.Bytes.putVarInt 26) Data.Monoid.<>
                           (((\ bs ->
                                (Data.ProtoLens.Encoding.Bytes.putVarInt
                                   (Prelude.fromIntegral (Data.ByteString.length bs)))
                                  Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs))
                              Prelude.. Data.ProtoLens.encodeMessage)
                             _v)
                      (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'innerNodes")
                         _x))
                     Data.Monoid.<>
                     (Data.ProtoLens.Encoding.Bytes.foldMapBuilder
                        (\ _v ->
                           (Data.ProtoLens.Encoding.Bytes.putVarInt 34) Data.Monoid.<>
                             (((\ bs ->
                                  (Data.ProtoLens.Encoding.Bytes.putVarInt
                                     (Prelude.fromIntegral (Data.ByteString.length bs)))
                                    Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                Prelude.. Data.ProtoLens.encodeMessage)
                               _v)
                        (Lens.Family2.view (Data.ProtoLens.Field.field @"vec'leaves") _x))
                       Data.Monoid.<>
                       Data.ProtoLens.Encoding.Wire.buildFieldSet
                         (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData RangeProof where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_RangeProof'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_RangeProof'key x__)
                    (Control.DeepSeq.deepseq (_RangeProof'leftPath x__)
                       (Control.DeepSeq.deepseq (_RangeProof'innerNodes x__)
                          (Control.DeepSeq.deepseq (_RangeProof'leaves x__) (()))))))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.key' @:: Lens' RemoveRequest Data.ByteString.ByteString@
 -}
data RemoveRequest = RemoveRequest{_RemoveRequest'key ::
                                   !Data.ByteString.ByteString,
                                   _RemoveRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
                       deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show RemoveRequest where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField RemoveRequest "key"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _RemoveRequest'key
               (\ x__ y__ -> x__{_RemoveRequest'key = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message RemoveRequest where
        messageName _ = Data.Text.pack "proto.RemoveRequest"
        fieldsByTag
          = let key__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "key"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"key"))
                      :: Data.ProtoLens.FieldDescriptor RemoveRequest
              in
              Data.Map.fromList [(Data.ProtoLens.Tag 1, key__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _RemoveRequest'_unknownFields
              (\ x__ y__ -> x__{_RemoveRequest'_unknownFields = y__})
        defMessage
          = RemoveRequest{_RemoveRequest'key = Data.ProtoLens.fieldDefault,
                          _RemoveRequest'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     RemoveRequest -> Data.ProtoLens.Encoding.Bytes.Parser RemoveRequest
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "key"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"key") y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "RemoveRequest"
        buildMessage
          = (\ _x ->
               (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"key") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 10) Data.Monoid.<>
                      (\ bs ->
                         (Data.ProtoLens.Encoding.Bytes.putVarInt
                            (Prelude.fromIntegral (Data.ByteString.length bs)))
                           Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                        _v)
                 Data.Monoid.<>
                 Data.ProtoLens.Encoding.Wire.buildFieldSet
                   (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData RemoveRequest where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_RemoveRequest'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_RemoveRequest'key x__) (())))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.value' @:: Lens' RemoveResponse Data.ByteString.ByteString@
    * 'Proto.Iavl.Api_Fields.removed' @:: Lens' RemoveResponse Prelude.Bool@
 -}
data RemoveResponse = RemoveResponse{_RemoveResponse'value ::
                                     !Data.ByteString.ByteString,
                                     _RemoveResponse'removed :: !Prelude.Bool,
                                     _RemoveResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
                        deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show RemoveResponse where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField RemoveResponse "value"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _RemoveResponse'value
               (\ x__ y__ -> x__{_RemoveResponse'value = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField RemoveResponse "removed"
           (Prelude.Bool)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _RemoveResponse'removed
               (\ x__ y__ -> x__{_RemoveResponse'removed = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message RemoveResponse where
        messageName _ = Data.Text.pack "proto.RemoveResponse"
        fieldsByTag
          = let value__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "value"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"value"))
                      :: Data.ProtoLens.FieldDescriptor RemoveResponse
                removed__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "removed"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"removed"))
                      :: Data.ProtoLens.FieldDescriptor RemoveResponse
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, value__field_descriptor),
                 (Data.ProtoLens.Tag 2, removed__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _RemoveResponse'_unknownFields
              (\ x__ y__ -> x__{_RemoveResponse'_unknownFields = y__})
        defMessage
          = RemoveResponse{_RemoveResponse'value =
                             Data.ProtoLens.fieldDefault,
                           _RemoveResponse'removed = Data.ProtoLens.fieldDefault,
                           _RemoveResponse'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     RemoveResponse ->
                       Data.ProtoLens.Encoding.Bytes.Parser RemoveResponse
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "value"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"value") y
                                              x)
                                16 -> do y <- (Prelude.fmap ((Prelude./=) 0)
                                                 Data.ProtoLens.Encoding.Bytes.getVarInt)
                                                Data.ProtoLens.Encoding.Bytes.<?> "removed"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"removed")
                                              y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "RemoveResponse"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"value") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 10) Data.Monoid.<>
                      (\ bs ->
                         (Data.ProtoLens.Encoding.Bytes.putVarInt
                            (Prelude.fromIntegral (Data.ByteString.length bs)))
                           Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                        _v)
                 Data.Monoid.<>
                 (let _v
                        = Lens.Family2.view (Data.ProtoLens.Field.field @"removed") _x
                    in
                    if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                      Data.Monoid.mempty else
                      (Data.ProtoLens.Encoding.Bytes.putVarInt 16) Data.Monoid.<>
                        ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                           (\ b -> if b then 1 else 0))
                          _v)
                   Data.Monoid.<>
                   Data.ProtoLens.Encoding.Wire.buildFieldSet
                     (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData RemoveResponse where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_RemoveResponse'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_RemoveResponse'value x__)
                    (Control.DeepSeq.deepseq (_RemoveResponse'removed x__) (()))))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.rootHash' @:: Lens' SaveVersionResponse Data.ByteString.ByteString@
    * 'Proto.Iavl.Api_Fields.version' @:: Lens' SaveVersionResponse Data.Int.Int64@
 -}
data SaveVersionResponse = SaveVersionResponse{_SaveVersionResponse'rootHash
                                               :: !Data.ByteString.ByteString,
                                               _SaveVersionResponse'version :: !Data.Int.Int64,
                                               _SaveVersionResponse'_unknownFields ::
                                               !Data.ProtoLens.FieldSet}
                             deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show SaveVersionResponse where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField SaveVersionResponse
           "rootHash"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _SaveVersionResponse'rootHash
               (\ x__ y__ -> x__{_SaveVersionResponse'rootHash = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField SaveVersionResponse
           "version"
           (Data.Int.Int64)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _SaveVersionResponse'version
               (\ x__ y__ -> x__{_SaveVersionResponse'version = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message SaveVersionResponse where
        messageName _ = Data.Text.pack "proto.SaveVersionResponse"
        fieldsByTag
          = let rootHash__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "root_hash"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"rootHash"))
                      :: Data.ProtoLens.FieldDescriptor SaveVersionResponse
                version__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "version"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"version"))
                      :: Data.ProtoLens.FieldDescriptor SaveVersionResponse
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, rootHash__field_descriptor),
                 (Data.ProtoLens.Tag 2, version__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _SaveVersionResponse'_unknownFields
              (\ x__ y__ -> x__{_SaveVersionResponse'_unknownFields = y__})
        defMessage
          = SaveVersionResponse{_SaveVersionResponse'rootHash =
                                  Data.ProtoLens.fieldDefault,
                                _SaveVersionResponse'version = Data.ProtoLens.fieldDefault,
                                _SaveVersionResponse'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     SaveVersionResponse ->
                       Data.ProtoLens.Encoding.Bytes.Parser SaveVersionResponse
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "root_hash"
                                         loop
                                           (Lens.Family2.set
                                              (Data.ProtoLens.Field.field @"rootHash")
                                              y
                                              x)
                                16 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                 Data.ProtoLens.Encoding.Bytes.getVarInt)
                                                Data.ProtoLens.Encoding.Bytes.<?> "version"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"version")
                                              y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "SaveVersionResponse"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"rootHash") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 10) Data.Monoid.<>
                      (\ bs ->
                         (Data.ProtoLens.Encoding.Bytes.putVarInt
                            (Prelude.fromIntegral (Data.ByteString.length bs)))
                           Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                        _v)
                 Data.Monoid.<>
                 (let _v
                        = Lens.Family2.view (Data.ProtoLens.Field.field @"version") _x
                    in
                    if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                      Data.Monoid.mempty else
                      (Data.ProtoLens.Encoding.Bytes.putVarInt 16) Data.Monoid.<>
                        ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                           Prelude.fromIntegral)
                          _v)
                   Data.Monoid.<>
                   Data.ProtoLens.Encoding.Wire.buildFieldSet
                     (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData SaveVersionResponse where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_SaveVersionResponse'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_SaveVersionResponse'rootHash x__)
                    (Control.DeepSeq.deepseq (_SaveVersionResponse'version x__) (()))))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.key' @:: Lens' SetRequest Data.ByteString.ByteString@
    * 'Proto.Iavl.Api_Fields.value' @:: Lens' SetRequest Data.ByteString.ByteString@
 -}
data SetRequest = SetRequest{_SetRequest'key ::
                             !Data.ByteString.ByteString,
                             _SetRequest'value :: !Data.ByteString.ByteString,
                             _SetRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
                    deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show SetRequest where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField SetRequest "key"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _SetRequest'key
               (\ x__ y__ -> x__{_SetRequest'key = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField SetRequest "value"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _SetRequest'value
               (\ x__ y__ -> x__{_SetRequest'value = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message SetRequest where
        messageName _ = Data.Text.pack "proto.SetRequest"
        fieldsByTag
          = let key__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "key"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"key"))
                      :: Data.ProtoLens.FieldDescriptor SetRequest
                value__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "value"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"value"))
                      :: Data.ProtoLens.FieldDescriptor SetRequest
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, key__field_descriptor),
                 (Data.ProtoLens.Tag 2, value__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _SetRequest'_unknownFields
              (\ x__ y__ -> x__{_SetRequest'_unknownFields = y__})
        defMessage
          = SetRequest{_SetRequest'key = Data.ProtoLens.fieldDefault,
                       _SetRequest'value = Data.ProtoLens.fieldDefault,
                       _SetRequest'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     SetRequest -> Data.ProtoLens.Encoding.Bytes.Parser SetRequest
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "key"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"key") y
                                              x)
                                18 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "value"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"value") y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "SetRequest"
        buildMessage
          = (\ _x ->
               (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"key") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 10) Data.Monoid.<>
                      (\ bs ->
                         (Data.ProtoLens.Encoding.Bytes.putVarInt
                            (Prelude.fromIntegral (Data.ByteString.length bs)))
                           Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                        _v)
                 Data.Monoid.<>
                 (let _v
                        = Lens.Family2.view (Data.ProtoLens.Field.field @"value") _x
                    in
                    if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                      Data.Monoid.mempty else
                      (Data.ProtoLens.Encoding.Bytes.putVarInt 18) Data.Monoid.<>
                        (\ bs ->
                           (Data.ProtoLens.Encoding.Bytes.putVarInt
                              (Prelude.fromIntegral (Data.ByteString.length bs)))
                             Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                          _v)
                   Data.Monoid.<>
                   Data.ProtoLens.Encoding.Wire.buildFieldSet
                     (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData SetRequest where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_SetRequest'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_SetRequest'key x__)
                    (Control.DeepSeq.deepseq (_SetRequest'value x__) (()))))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.result' @:: Lens' SetResponse Prelude.Bool@
 -}
data SetResponse = SetResponse{_SetResponse'result ::
                               !Prelude.Bool,
                               _SetResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
                     deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show SetResponse where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField SetResponse "result"
           (Prelude.Bool)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _SetResponse'result
               (\ x__ y__ -> x__{_SetResponse'result = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message SetResponse where
        messageName _ = Data.Text.pack "proto.SetResponse"
        fieldsByTag
          = let result__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "result"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"result"))
                      :: Data.ProtoLens.FieldDescriptor SetResponse
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, result__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _SetResponse'_unknownFields
              (\ x__ y__ -> x__{_SetResponse'_unknownFields = y__})
        defMessage
          = SetResponse{_SetResponse'result = Data.ProtoLens.fieldDefault,
                        _SetResponse'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     SetResponse -> Data.ProtoLens.Encoding.Bytes.Parser SetResponse
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                8 -> do y <- (Prelude.fmap ((Prelude./=) 0)
                                                Data.ProtoLens.Encoding.Bytes.getVarInt)
                                               Data.ProtoLens.Encoding.Bytes.<?> "result"
                                        loop
                                          (Lens.Family2.set (Data.ProtoLens.Field.field @"result") y
                                             x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "SetResponse"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"result") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 8) Data.Monoid.<>
                      ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                         (\ b -> if b then 1 else 0))
                        _v)
                 Data.Monoid.<>
                 Data.ProtoLens.Encoding.Wire.buildFieldSet
                   (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData SetResponse where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_SetResponse'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_SetResponse'result x__) (())))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.rootHash' @:: Lens' VerifyAbsenceRequest Data.ByteString.ByteString@
    * 'Proto.Iavl.Api_Fields.proof' @:: Lens' VerifyAbsenceRequest RangeProof@
    * 'Proto.Iavl.Api_Fields.maybe'proof' @:: Lens' VerifyAbsenceRequest (Prelude.Maybe RangeProof)@
    * 'Proto.Iavl.Api_Fields.key' @:: Lens' VerifyAbsenceRequest Data.ByteString.ByteString@
 -}
data VerifyAbsenceRequest = VerifyAbsenceRequest{_VerifyAbsenceRequest'rootHash
                                                 :: !Data.ByteString.ByteString,
                                                 _VerifyAbsenceRequest'proof ::
                                                 !(Prelude.Maybe RangeProof),
                                                 _VerifyAbsenceRequest'key ::
                                                 !Data.ByteString.ByteString,
                                                 _VerifyAbsenceRequest'_unknownFields ::
                                                 !Data.ProtoLens.FieldSet}
                              deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show VerifyAbsenceRequest where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField VerifyAbsenceRequest
           "rootHash"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _VerifyAbsenceRequest'rootHash
               (\ x__ y__ -> x__{_VerifyAbsenceRequest'rootHash = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField VerifyAbsenceRequest "proof"
           (RangeProof)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _VerifyAbsenceRequest'proof
               (\ x__ y__ -> x__{_VerifyAbsenceRequest'proof = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.defMessage
instance Data.ProtoLens.Field.HasField VerifyAbsenceRequest
           "maybe'proof"
           (Prelude.Maybe RangeProof)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _VerifyAbsenceRequest'proof
               (\ x__ y__ -> x__{_VerifyAbsenceRequest'proof = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField VerifyAbsenceRequest "key"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _VerifyAbsenceRequest'key
               (\ x__ y__ -> x__{_VerifyAbsenceRequest'key = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message VerifyAbsenceRequest where
        messageName _ = Data.Text.pack "proto.VerifyAbsenceRequest"
        fieldsByTag
          = let rootHash__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "root_hash"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"rootHash"))
                      :: Data.ProtoLens.FieldDescriptor VerifyAbsenceRequest
                proof__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "proof"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor RangeProof)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'proof"))
                      :: Data.ProtoLens.FieldDescriptor VerifyAbsenceRequest
                key__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "key"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"key"))
                      :: Data.ProtoLens.FieldDescriptor VerifyAbsenceRequest
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, rootHash__field_descriptor),
                 (Data.ProtoLens.Tag 2, proof__field_descriptor),
                 (Data.ProtoLens.Tag 3, key__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _VerifyAbsenceRequest'_unknownFields
              (\ x__ y__ -> x__{_VerifyAbsenceRequest'_unknownFields = y__})
        defMessage
          = VerifyAbsenceRequest{_VerifyAbsenceRequest'rootHash =
                                   Data.ProtoLens.fieldDefault,
                                 _VerifyAbsenceRequest'proof = Prelude.Nothing,
                                 _VerifyAbsenceRequest'key = Data.ProtoLens.fieldDefault,
                                 _VerifyAbsenceRequest'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     VerifyAbsenceRequest ->
                       Data.ProtoLens.Encoding.Bytes.Parser VerifyAbsenceRequest
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "root_hash"
                                         loop
                                           (Lens.Family2.set
                                              (Data.ProtoLens.Field.field @"rootHash")
                                              y
                                              x)
                                18 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.isolate
                                                    (Prelude.fromIntegral len)
                                                    Data.ProtoLens.parseMessage)
                                                Data.ProtoLens.Encoding.Bytes.<?> "proof"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"proof") y
                                              x)
                                26 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "key"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"key") y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "VerifyAbsenceRequest"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"rootHash") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 10) Data.Monoid.<>
                      (\ bs ->
                         (Data.ProtoLens.Encoding.Bytes.putVarInt
                            (Prelude.fromIntegral (Data.ByteString.length bs)))
                           Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                        _v)
                 Data.Monoid.<>
                 (case
                    Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'proof") _x of
                      (Prelude.Nothing) -> Data.Monoid.mempty
                      Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
                                           Data.Monoid.<>
                                           (((\ bs ->
                                                (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                   (Prelude.fromIntegral
                                                      (Data.ByteString.length bs)))
                                                  Data.Monoid.<>
                                                  Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                              Prelude.. Data.ProtoLens.encodeMessage)
                                             _v)
                   Data.Monoid.<>
                   (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"key") _x
                      in
                      if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                        Data.Monoid.mempty else
                        (Data.ProtoLens.Encoding.Bytes.putVarInt 26) Data.Monoid.<>
                          (\ bs ->
                             (Data.ProtoLens.Encoding.Bytes.putVarInt
                                (Prelude.fromIntegral (Data.ByteString.length bs)))
                               Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                            _v)
                     Data.Monoid.<>
                     Data.ProtoLens.Encoding.Wire.buildFieldSet
                       (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData VerifyAbsenceRequest where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_VerifyAbsenceRequest'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_VerifyAbsenceRequest'rootHash x__)
                    (Control.DeepSeq.deepseq (_VerifyAbsenceRequest'proof x__)
                       (Control.DeepSeq.deepseq (_VerifyAbsenceRequest'key x__) (())))))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.rootHash' @:: Lens' VerifyItemRequest Data.ByteString.ByteString@
    * 'Proto.Iavl.Api_Fields.proof' @:: Lens' VerifyItemRequest RangeProof@
    * 'Proto.Iavl.Api_Fields.maybe'proof' @:: Lens' VerifyItemRequest (Prelude.Maybe RangeProof)@
    * 'Proto.Iavl.Api_Fields.key' @:: Lens' VerifyItemRequest Data.ByteString.ByteString@
    * 'Proto.Iavl.Api_Fields.value' @:: Lens' VerifyItemRequest Data.ByteString.ByteString@
 -}
data VerifyItemRequest = VerifyItemRequest{_VerifyItemRequest'rootHash
                                           :: !Data.ByteString.ByteString,
                                           _VerifyItemRequest'proof :: !(Prelude.Maybe RangeProof),
                                           _VerifyItemRequest'key :: !Data.ByteString.ByteString,
                                           _VerifyItemRequest'value :: !Data.ByteString.ByteString,
                                           _VerifyItemRequest'_unknownFields ::
                                           !Data.ProtoLens.FieldSet}
                           deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show VerifyItemRequest where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField VerifyItemRequest "rootHash"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _VerifyItemRequest'rootHash
               (\ x__ y__ -> x__{_VerifyItemRequest'rootHash = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField VerifyItemRequest "proof"
           (RangeProof)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _VerifyItemRequest'proof
               (\ x__ y__ -> x__{_VerifyItemRequest'proof = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.defMessage
instance Data.ProtoLens.Field.HasField VerifyItemRequest
           "maybe'proof"
           (Prelude.Maybe RangeProof)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _VerifyItemRequest'proof
               (\ x__ y__ -> x__{_VerifyItemRequest'proof = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField VerifyItemRequest "key"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _VerifyItemRequest'key
               (\ x__ y__ -> x__{_VerifyItemRequest'key = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField VerifyItemRequest "value"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _VerifyItemRequest'value
               (\ x__ y__ -> x__{_VerifyItemRequest'value = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message VerifyItemRequest where
        messageName _ = Data.Text.pack "proto.VerifyItemRequest"
        fieldsByTag
          = let rootHash__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "root_hash"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"rootHash"))
                      :: Data.ProtoLens.FieldDescriptor VerifyItemRequest
                proof__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "proof"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor RangeProof)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'proof"))
                      :: Data.ProtoLens.FieldDescriptor VerifyItemRequest
                key__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "key"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"key"))
                      :: Data.ProtoLens.FieldDescriptor VerifyItemRequest
                value__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "value"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"value"))
                      :: Data.ProtoLens.FieldDescriptor VerifyItemRequest
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, rootHash__field_descriptor),
                 (Data.ProtoLens.Tag 2, proof__field_descriptor),
                 (Data.ProtoLens.Tag 3, key__field_descriptor),
                 (Data.ProtoLens.Tag 4, value__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _VerifyItemRequest'_unknownFields
              (\ x__ y__ -> x__{_VerifyItemRequest'_unknownFields = y__})
        defMessage
          = VerifyItemRequest{_VerifyItemRequest'rootHash =
                                Data.ProtoLens.fieldDefault,
                              _VerifyItemRequest'proof = Prelude.Nothing,
                              _VerifyItemRequest'key = Data.ProtoLens.fieldDefault,
                              _VerifyItemRequest'value = Data.ProtoLens.fieldDefault,
                              _VerifyItemRequest'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     VerifyItemRequest ->
                       Data.ProtoLens.Encoding.Bytes.Parser VerifyItemRequest
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "root_hash"
                                         loop
                                           (Lens.Family2.set
                                              (Data.ProtoLens.Field.field @"rootHash")
                                              y
                                              x)
                                18 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.isolate
                                                    (Prelude.fromIntegral len)
                                                    Data.ProtoLens.parseMessage)
                                                Data.ProtoLens.Encoding.Bytes.<?> "proof"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"proof") y
                                              x)
                                26 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "key"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"key") y
                                              x)
                                34 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "value"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"value") y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "VerifyItemRequest"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"rootHash") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 10) Data.Monoid.<>
                      (\ bs ->
                         (Data.ProtoLens.Encoding.Bytes.putVarInt
                            (Prelude.fromIntegral (Data.ByteString.length bs)))
                           Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                        _v)
                 Data.Monoid.<>
                 (case
                    Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'proof") _x of
                      (Prelude.Nothing) -> Data.Monoid.mempty
                      Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
                                           Data.Monoid.<>
                                           (((\ bs ->
                                                (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                   (Prelude.fromIntegral
                                                      (Data.ByteString.length bs)))
                                                  Data.Monoid.<>
                                                  Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                              Prelude.. Data.ProtoLens.encodeMessage)
                                             _v)
                   Data.Monoid.<>
                   (let _v = Lens.Family2.view (Data.ProtoLens.Field.field @"key") _x
                      in
                      if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                        Data.Monoid.mempty else
                        (Data.ProtoLens.Encoding.Bytes.putVarInt 26) Data.Monoid.<>
                          (\ bs ->
                             (Data.ProtoLens.Encoding.Bytes.putVarInt
                                (Prelude.fromIntegral (Data.ByteString.length bs)))
                               Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                            _v)
                     Data.Monoid.<>
                     (let _v
                            = Lens.Family2.view (Data.ProtoLens.Field.field @"value") _x
                        in
                        if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                          Data.Monoid.mempty else
                          (Data.ProtoLens.Encoding.Bytes.putVarInt 34) Data.Monoid.<>
                            (\ bs ->
                               (Data.ProtoLens.Encoding.Bytes.putVarInt
                                  (Prelude.fromIntegral (Data.ByteString.length bs)))
                                 Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                              _v)
                       Data.Monoid.<>
                       Data.ProtoLens.Encoding.Wire.buildFieldSet
                         (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData VerifyItemRequest where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_VerifyItemRequest'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_VerifyItemRequest'rootHash x__)
                    (Control.DeepSeq.deepseq (_VerifyItemRequest'proof x__)
                       (Control.DeepSeq.deepseq (_VerifyItemRequest'key x__)
                          (Control.DeepSeq.deepseq (_VerifyItemRequest'value x__) (()))))))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.rootHash' @:: Lens' VerifyRequest Data.ByteString.ByteString@
    * 'Proto.Iavl.Api_Fields.proof' @:: Lens' VerifyRequest RangeProof@
    * 'Proto.Iavl.Api_Fields.maybe'proof' @:: Lens' VerifyRequest (Prelude.Maybe RangeProof)@
 -}
data VerifyRequest = VerifyRequest{_VerifyRequest'rootHash ::
                                   !Data.ByteString.ByteString,
                                   _VerifyRequest'proof :: !(Prelude.Maybe RangeProof),
                                   _VerifyRequest'_unknownFields :: !Data.ProtoLens.FieldSet}
                       deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show VerifyRequest where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField VerifyRequest "rootHash"
           (Data.ByteString.ByteString)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _VerifyRequest'rootHash
               (\ x__ y__ -> x__{_VerifyRequest'rootHash = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Field.HasField VerifyRequest "proof"
           (RangeProof)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _VerifyRequest'proof
               (\ x__ y__ -> x__{_VerifyRequest'proof = y__}))
              Prelude.. Data.ProtoLens.maybeLens Data.ProtoLens.defMessage
instance Data.ProtoLens.Field.HasField VerifyRequest "maybe'proof"
           (Prelude.Maybe RangeProof)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _VerifyRequest'proof
               (\ x__ y__ -> x__{_VerifyRequest'proof = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message VerifyRequest where
        messageName _ = Data.Text.pack "proto.VerifyRequest"
        fieldsByTag
          = let rootHash__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "root_hash"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BytesField ::
                         Data.ProtoLens.FieldTypeDescriptor Data.ByteString.ByteString)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"rootHash"))
                      :: Data.ProtoLens.FieldDescriptor VerifyRequest
                proof__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "proof"
                      (Data.ProtoLens.MessageField Data.ProtoLens.MessageType ::
                         Data.ProtoLens.FieldTypeDescriptor RangeProof)
                      (Data.ProtoLens.OptionalField
                         (Data.ProtoLens.Field.field @"maybe'proof"))
                      :: Data.ProtoLens.FieldDescriptor VerifyRequest
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, rootHash__field_descriptor),
                 (Data.ProtoLens.Tag 2, proof__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _VerifyRequest'_unknownFields
              (\ x__ y__ -> x__{_VerifyRequest'_unknownFields = y__})
        defMessage
          = VerifyRequest{_VerifyRequest'rootHash =
                            Data.ProtoLens.fieldDefault,
                          _VerifyRequest'proof = Prelude.Nothing,
                          _VerifyRequest'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     VerifyRequest -> Data.ProtoLens.Encoding.Bytes.Parser VerifyRequest
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                10 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.getBytes
                                                    (Prelude.fromIntegral len))
                                                Data.ProtoLens.Encoding.Bytes.<?> "root_hash"
                                         loop
                                           (Lens.Family2.set
                                              (Data.ProtoLens.Field.field @"rootHash")
                                              y
                                              x)
                                18 -> do y <- (do len <- Data.ProtoLens.Encoding.Bytes.getVarInt
                                                  Data.ProtoLens.Encoding.Bytes.isolate
                                                    (Prelude.fromIntegral len)
                                                    Data.ProtoLens.parseMessage)
                                                Data.ProtoLens.Encoding.Bytes.<?> "proof"
                                         loop
                                           (Lens.Family2.set (Data.ProtoLens.Field.field @"proof") y
                                              x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "VerifyRequest"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"rootHash") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 10) Data.Monoid.<>
                      (\ bs ->
                         (Data.ProtoLens.Encoding.Bytes.putVarInt
                            (Prelude.fromIntegral (Data.ByteString.length bs)))
                           Data.Monoid.<> Data.ProtoLens.Encoding.Bytes.putBytes bs)
                        _v)
                 Data.Monoid.<>
                 (case
                    Lens.Family2.view (Data.ProtoLens.Field.field @"maybe'proof") _x of
                      (Prelude.Nothing) -> Data.Monoid.mempty
                      Prelude.Just _v -> (Data.ProtoLens.Encoding.Bytes.putVarInt 18)
                                           Data.Monoid.<>
                                           (((\ bs ->
                                                (Data.ProtoLens.Encoding.Bytes.putVarInt
                                                   (Prelude.fromIntegral
                                                      (Data.ByteString.length bs)))
                                                  Data.Monoid.<>
                                                  Data.ProtoLens.Encoding.Bytes.putBytes bs))
                                              Prelude.. Data.ProtoLens.encodeMessage)
                                             _v)
                   Data.Monoid.<>
                   Data.ProtoLens.Encoding.Wire.buildFieldSet
                     (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData VerifyRequest where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_VerifyRequest'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_VerifyRequest'rootHash x__)
                    (Control.DeepSeq.deepseq (_VerifyRequest'proof x__) (()))))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.version' @:: Lens' VersionExistsRequest Data.Int.Int64@
 -}
data VersionExistsRequest = VersionExistsRequest{_VersionExistsRequest'version
                                                 :: !Data.Int.Int64,
                                                 _VersionExistsRequest'_unknownFields ::
                                                 !Data.ProtoLens.FieldSet}
                              deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show VersionExistsRequest where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField VersionExistsRequest
           "version"
           (Data.Int.Int64)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _VersionExistsRequest'version
               (\ x__ y__ -> x__{_VersionExistsRequest'version = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message VersionExistsRequest where
        messageName _ = Data.Text.pack "proto.VersionExistsRequest"
        fieldsByTag
          = let version__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "version"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"version"))
                      :: Data.ProtoLens.FieldDescriptor VersionExistsRequest
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, version__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _VersionExistsRequest'_unknownFields
              (\ x__ y__ -> x__{_VersionExistsRequest'_unknownFields = y__})
        defMessage
          = VersionExistsRequest{_VersionExistsRequest'version =
                                   Data.ProtoLens.fieldDefault,
                                 _VersionExistsRequest'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     VersionExistsRequest ->
                       Data.ProtoLens.Encoding.Bytes.Parser VersionExistsRequest
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                8 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                Data.ProtoLens.Encoding.Bytes.getVarInt)
                                               Data.ProtoLens.Encoding.Bytes.<?> "version"
                                        loop
                                          (Lens.Family2.set (Data.ProtoLens.Field.field @"version")
                                             y
                                             x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "VersionExistsRequest"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"version") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 8) Data.Monoid.<>
                      ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                         Prelude.fromIntegral)
                        _v)
                 Data.Monoid.<>
                 Data.ProtoLens.Encoding.Wire.buildFieldSet
                   (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData VersionExistsRequest where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_VersionExistsRequest'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_VersionExistsRequest'version x__) (())))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.result' @:: Lens' VersionExistsResponse Prelude.Bool@
 -}
data VersionExistsResponse = VersionExistsResponse{_VersionExistsResponse'result
                                                   :: !Prelude.Bool,
                                                   _VersionExistsResponse'_unknownFields ::
                                                   !Data.ProtoLens.FieldSet}
                               deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show VersionExistsResponse where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField VersionExistsResponse
           "result"
           (Prelude.Bool)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _VersionExistsResponse'result
               (\ x__ y__ -> x__{_VersionExistsResponse'result = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message VersionExistsResponse where
        messageName _ = Data.Text.pack "proto.VersionExistsResponse"
        fieldsByTag
          = let result__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "result"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.BoolField ::
                         Data.ProtoLens.FieldTypeDescriptor Prelude.Bool)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"result"))
                      :: Data.ProtoLens.FieldDescriptor VersionExistsResponse
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, result__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _VersionExistsResponse'_unknownFields
              (\ x__ y__ -> x__{_VersionExistsResponse'_unknownFields = y__})
        defMessage
          = VersionExistsResponse{_VersionExistsResponse'result =
                                    Data.ProtoLens.fieldDefault,
                                  _VersionExistsResponse'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     VersionExistsResponse ->
                       Data.ProtoLens.Encoding.Bytes.Parser VersionExistsResponse
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                8 -> do y <- (Prelude.fmap ((Prelude./=) 0)
                                                Data.ProtoLens.Encoding.Bytes.getVarInt)
                                               Data.ProtoLens.Encoding.Bytes.<?> "result"
                                        loop
                                          (Lens.Family2.set (Data.ProtoLens.Field.field @"result") y
                                             x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "VersionExistsResponse"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"result") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 8) Data.Monoid.<>
                      ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                         (\ b -> if b then 1 else 0))
                        _v)
                 Data.Monoid.<>
                 Data.ProtoLens.Encoding.Wire.buildFieldSet
                   (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData VersionExistsResponse where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_VersionExistsResponse'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_VersionExistsResponse'result x__) (())))
{- | Fields :

    * 'Proto.Iavl.Api_Fields.version' @:: Lens' VersionResponse Data.Int.Int64@
 -}
data VersionResponse = VersionResponse{_VersionResponse'version ::
                                       !Data.Int.Int64,
                                       _VersionResponse'_unknownFields :: !Data.ProtoLens.FieldSet}
                         deriving (Prelude.Eq, Prelude.Ord)
instance Prelude.Show VersionResponse where
        showsPrec _ __x __s
          = Prelude.showChar '{'
              (Prelude.showString (Data.ProtoLens.showMessageShort __x)
                 (Prelude.showChar '}' __s))
instance Data.ProtoLens.Field.HasField VersionResponse "version"
           (Data.Int.Int64)
         where
        fieldOf _
          = (Lens.Family2.Unchecked.lens _VersionResponse'version
               (\ x__ y__ -> x__{_VersionResponse'version = y__}))
              Prelude.. Prelude.id
instance Data.ProtoLens.Message VersionResponse where
        messageName _ = Data.Text.pack "proto.VersionResponse"
        fieldsByTag
          = let version__field_descriptor
                  = Data.ProtoLens.FieldDescriptor "version"
                      (Data.ProtoLens.ScalarField Data.ProtoLens.Int64Field ::
                         Data.ProtoLens.FieldTypeDescriptor Data.Int.Int64)
                      (Data.ProtoLens.PlainField Data.ProtoLens.Optional
                         (Data.ProtoLens.Field.field @"version"))
                      :: Data.ProtoLens.FieldDescriptor VersionResponse
              in
              Data.Map.fromList
                [(Data.ProtoLens.Tag 1, version__field_descriptor)]
        unknownFields
          = Lens.Family2.Unchecked.lens _VersionResponse'_unknownFields
              (\ x__ y__ -> x__{_VersionResponse'_unknownFields = y__})
        defMessage
          = VersionResponse{_VersionResponse'version =
                              Data.ProtoLens.fieldDefault,
                            _VersionResponse'_unknownFields = ([])}
        parseMessage
          = let loop ::
                     VersionResponse ->
                       Data.ProtoLens.Encoding.Bytes.Parser VersionResponse
                loop x
                  = do end <- Data.ProtoLens.Encoding.Bytes.atEnd
                       if end then
                         do let missing = [] in
                              if Prelude.null missing then Prelude.return () else
                                Prelude.fail
                                  (("Missing required fields: ") Prelude.++
                                     Prelude.show (missing :: ([Prelude.String])))
                            Prelude.return
                              (Lens.Family2.over Data.ProtoLens.unknownFields
                                 (\ !t -> Prelude.reverse t)
                                 x)
                         else
                         do tag <- Data.ProtoLens.Encoding.Bytes.getVarInt
                            case tag of
                                8 -> do y <- (Prelude.fmap Prelude.fromIntegral
                                                Data.ProtoLens.Encoding.Bytes.getVarInt)
                                               Data.ProtoLens.Encoding.Bytes.<?> "version"
                                        loop
                                          (Lens.Family2.set (Data.ProtoLens.Field.field @"version")
                                             y
                                             x)
                                wire -> do !y <- Data.ProtoLens.Encoding.Wire.parseTaggedValueFromWire
                                                   wire
                                           loop
                                             (Lens.Family2.over Data.ProtoLens.unknownFields
                                                (\ !t -> (:) y t)
                                                x)
              in
              (do loop Data.ProtoLens.defMessage)
                Data.ProtoLens.Encoding.Bytes.<?> "VersionResponse"
        buildMessage
          = (\ _x ->
               (let _v
                      = Lens.Family2.view (Data.ProtoLens.Field.field @"version") _x
                  in
                  if (_v) Prelude.== Data.ProtoLens.fieldDefault then
                    Data.Monoid.mempty else
                    (Data.ProtoLens.Encoding.Bytes.putVarInt 8) Data.Monoid.<>
                      ((Data.ProtoLens.Encoding.Bytes.putVarInt) Prelude..
                         Prelude.fromIntegral)
                        _v)
                 Data.Monoid.<>
                 Data.ProtoLens.Encoding.Wire.buildFieldSet
                   (Lens.Family2.view Data.ProtoLens.unknownFields _x))
instance Control.DeepSeq.NFData VersionResponse where
        rnf
          = (\ x__ ->
               Control.DeepSeq.deepseq (_VersionResponse'_unknownFields x__)
                 (Control.DeepSeq.deepseq (_VersionResponse'version x__) (())))
data IAVLService = IAVLService{}
                     deriving ()
instance Data.ProtoLens.Service.Types.Service IAVLService where
        type ServiceName IAVLService = "IAVLService"
        type ServicePackage IAVLService = "proto"
        type ServiceMethods IAVLService =
             '["deleteVersion", "get", "getVersioned", "getVersionedWithProof",
               "getWithProof", "has", "hash", "remove", "rollback", "saveVersion",
               "set", "verify", "verifyAbsence", "verifyItem", "version",
               "versionExists"]
instance Data.ProtoLens.Service.Types.HasMethodImpl IAVLService
           "has"
         where
        type MethodName IAVLService "has" = "Has"
        type MethodInput IAVLService "has" = HasRequest
        type MethodOutput IAVLService "has" = HasResponse
        type MethodStreamingType IAVLService "has" =
             'Data.ProtoLens.Service.Types.NonStreaming
instance Data.ProtoLens.Service.Types.HasMethodImpl IAVLService
           "get"
         where
        type MethodName IAVLService "get" = "Get"
        type MethodInput IAVLService "get" = GetRequest
        type MethodOutput IAVLService "get" = GetResponse
        type MethodStreamingType IAVLService "get" =
             'Data.ProtoLens.Service.Types.NonStreaming
instance Data.ProtoLens.Service.Types.HasMethodImpl IAVLService
           "getWithProof"
         where
        type MethodName IAVLService "getWithProof" = "GetWithProof"
        type MethodInput IAVLService "getWithProof" = GetRequest
        type MethodOutput IAVLService "getWithProof" = GetWithProofResponse
        type MethodStreamingType IAVLService "getWithProof" =
             'Data.ProtoLens.Service.Types.NonStreaming
instance Data.ProtoLens.Service.Types.HasMethodImpl IAVLService
           "getVersioned"
         where
        type MethodName IAVLService "getVersioned" = "GetVersioned"
        type MethodInput IAVLService "getVersioned" = GetVersionedRequest
        type MethodOutput IAVLService "getVersioned" = GetResponse
        type MethodStreamingType IAVLService "getVersioned" =
             'Data.ProtoLens.Service.Types.NonStreaming
instance Data.ProtoLens.Service.Types.HasMethodImpl IAVLService
           "getVersionedWithProof"
         where
        type MethodName IAVLService "getVersionedWithProof" =
             "GetVersionedWithProof"
        type MethodInput IAVLService "getVersionedWithProof" =
             GetVersionedRequest
        type MethodOutput IAVLService "getVersionedWithProof" =
             GetWithProofResponse
        type MethodStreamingType IAVLService "getVersionedWithProof" =
             'Data.ProtoLens.Service.Types.NonStreaming
instance Data.ProtoLens.Service.Types.HasMethodImpl IAVLService
           "set"
         where
        type MethodName IAVLService "set" = "Set"
        type MethodInput IAVLService "set" = SetRequest
        type MethodOutput IAVLService "set" = SetResponse
        type MethodStreamingType IAVLService "set" =
             'Data.ProtoLens.Service.Types.NonStreaming
instance Data.ProtoLens.Service.Types.HasMethodImpl IAVLService
           "remove"
         where
        type MethodName IAVLService "remove" = "Remove"
        type MethodInput IAVLService "remove" = RemoveRequest
        type MethodOutput IAVLService "remove" = RemoveResponse
        type MethodStreamingType IAVLService "remove" =
             'Data.ProtoLens.Service.Types.NonStreaming
instance Data.ProtoLens.Service.Types.HasMethodImpl IAVLService
           "saveVersion"
         where
        type MethodName IAVLService "saveVersion" = "SaveVersion"
        type MethodInput IAVLService "saveVersion" =
             Proto.Google.Protobuf.Empty.Empty
        type MethodOutput IAVLService "saveVersion" = SaveVersionResponse
        type MethodStreamingType IAVLService "saveVersion" =
             'Data.ProtoLens.Service.Types.NonStreaming
instance Data.ProtoLens.Service.Types.HasMethodImpl IAVLService
           "deleteVersion"
         where
        type MethodName IAVLService "deleteVersion" = "DeleteVersion"
        type MethodInput IAVLService "deleteVersion" = DeleteVersionRequest
        type MethodOutput IAVLService "deleteVersion" =
             DeleteVersionResponse
        type MethodStreamingType IAVLService "deleteVersion" =
             'Data.ProtoLens.Service.Types.NonStreaming
instance Data.ProtoLens.Service.Types.HasMethodImpl IAVLService
           "version"
         where
        type MethodName IAVLService "version" = "Version"
        type MethodInput IAVLService "version" =
             Proto.Google.Protobuf.Empty.Empty
        type MethodOutput IAVLService "version" = VersionResponse
        type MethodStreamingType IAVLService "version" =
             'Data.ProtoLens.Service.Types.NonStreaming
instance Data.ProtoLens.Service.Types.HasMethodImpl IAVLService
           "hash"
         where
        type MethodName IAVLService "hash" = "Hash"
        type MethodInput IAVLService "hash" =
             Proto.Google.Protobuf.Empty.Empty
        type MethodOutput IAVLService "hash" = HashResponse
        type MethodStreamingType IAVLService "hash" =
             'Data.ProtoLens.Service.Types.NonStreaming
instance Data.ProtoLens.Service.Types.HasMethodImpl IAVLService
           "versionExists"
         where
        type MethodName IAVLService "versionExists" = "VersionExists"
        type MethodInput IAVLService "versionExists" = VersionExistsRequest
        type MethodOutput IAVLService "versionExists" =
             VersionExistsResponse
        type MethodStreamingType IAVLService "versionExists" =
             'Data.ProtoLens.Service.Types.NonStreaming
instance Data.ProtoLens.Service.Types.HasMethodImpl IAVLService
           "verify"
         where
        type MethodName IAVLService "verify" = "Verify"
        type MethodInput IAVLService "verify" = VerifyRequest
        type MethodOutput IAVLService "verify" =
             Proto.Google.Protobuf.Empty.Empty
        type MethodStreamingType IAVLService "verify" =
             'Data.ProtoLens.Service.Types.NonStreaming
instance Data.ProtoLens.Service.Types.HasMethodImpl IAVLService
           "verifyItem"
         where
        type MethodName IAVLService "verifyItem" = "VerifyItem"
        type MethodInput IAVLService "verifyItem" = VerifyItemRequest
        type MethodOutput IAVLService "verifyItem" =
             Proto.Google.Protobuf.Empty.Empty
        type MethodStreamingType IAVLService "verifyItem" =
             'Data.ProtoLens.Service.Types.NonStreaming
instance Data.ProtoLens.Service.Types.HasMethodImpl IAVLService
           "verifyAbsence"
         where
        type MethodName IAVLService "verifyAbsence" = "VerifyAbsence"
        type MethodInput IAVLService "verifyAbsence" = VerifyAbsenceRequest
        type MethodOutput IAVLService "verifyAbsence" =
             Proto.Google.Protobuf.Empty.Empty
        type MethodStreamingType IAVLService "verifyAbsence" =
             'Data.ProtoLens.Service.Types.NonStreaming
instance Data.ProtoLens.Service.Types.HasMethodImpl IAVLService
           "rollback"
         where
        type MethodName IAVLService "rollback" = "Rollback"
        type MethodInput IAVLService "rollback" =
             Proto.Google.Protobuf.Empty.Empty
        type MethodOutput IAVLService "rollback" =
             Proto.Google.Protobuf.Empty.Empty
        type MethodStreamingType IAVLService "rollback" =
             'Data.ProtoLens.Service.Types.NonStreaming